chromeos/dbus/nfc_client_unittest.cc

   1 // Copyright 2013 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 "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "chromeos/dbus/nfc_adapter_client.h"
   8 #include "chromeos/dbus/nfc_client_helpers.h"
   9 #include "chromeos/dbus/nfc_device_client.h"
  10 #include "chromeos/dbus/nfc_manager_client.h"
  11 #include "chromeos/dbus/nfc_record_client.h"
  12 #include "chromeos/dbus/nfc_tag_client.h"
  13 #include "dbus/mock_bus.h"
  14 #include "dbus/mock_object_proxy.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "third_party/cros_system_api/dbus/service_constants.h"
  18
  19 using ::testing::_;
  20 using ::testing::Invoke;
  21 using ::testing::Mock;
  22 using ::testing::Return;
  23
  24 using chromeos::nfc_client_helpers::ObjectPathVector;
  25
  26 namespace chromeos {
  27
  28 namespace {
  29
  30 // D-Bus service name used by the test.
  31 const char kTestServiceName[] = "test.service.name";
  32
  33 // Object paths that are used for testing.
  34 const char kTestManagerPath[] = "/test/nfc/manager";
  35 const char kTestAdapterPath0[] = "/test/nfc/adapter0";
  36 const char kTestAdapterPath1[] = "/test/nfc/adapter1";
  37 const char kTestDevicePath0[] = "/test/nfc/device0";
  38 const char kTestDevicePath1[] = "/test/nfc/device1";
  39 const char kTestRecordPath0[] = "/test/nfc/record0";
  40 const char kTestRecordPath1[] = "/test/nfc/record1";
  41 const char kTestRecordPath2[] = "/test/nfc/record2";
  42 const char kTestRecordPath3[] = "/test/nfc/record3";
  43 const char kTestTagPath0[] = "/test/nfc/tag0";
  44 const char kTestTagPath1[] = "/test/nfc/tag1";
  45
  46 class MockNfcManagerObserver : public NfcManagerClient::Observer {
  47  public:
  48   MOCK_METHOD1(AdapterAdded, void(const dbus::ObjectPath&));
  49   MOCK_METHOD1(AdapterRemoved, void(const dbus::ObjectPath&));
  50   MOCK_METHOD1(ManagerPropertyChanged, void(const std::string&));
  51 };
  52
  53 class MockNfcAdapterObserver : public NfcAdapterClient::Observer {
  54  public:
  55   MOCK_METHOD1(AdapterAdded, void(const dbus::ObjectPath&));
  56   MOCK_METHOD1(AdapterRemoved, void(const dbus::ObjectPath&));
  57   MOCK_METHOD2(AdapterPropertyChanged, void(const dbus::ObjectPath&,
  58                                             const std::string&));
  59 };
  60
  61 class MockNfcDeviceObserver : public NfcDeviceClient::Observer {
  62  public:
  63   MOCK_METHOD1(DeviceAdded, void(const dbus::ObjectPath&));
  64   MOCK_METHOD1(DeviceRemoved, void(const dbus::ObjectPath&));
  65   MOCK_METHOD2(DevicePropertyChanged, void(const dbus::ObjectPath&,
  66                                            const std::string&));
  67 };
  68
  69 class MockNfcRecordObserver : public NfcRecordClient::Observer {
  70  public:
  71   MOCK_METHOD1(RecordAdded, void(const dbus::ObjectPath&));
  72   MOCK_METHOD1(RecordRemoved, void(const dbus::ObjectPath&));
  73   MOCK_METHOD2(RecordPropertyChanged, void(const dbus::ObjectPath&,
  74                                            const std::string&));
  75   MOCK_METHOD1(RecordPropertiesReceived, void(const dbus::ObjectPath&));
  76 };
  77
  78 class MockNfcTagObserver : public NfcTagClient::Observer {
  79  public:
  80   MOCK_METHOD1(TagAdded, void(const dbus::ObjectPath&));
  81   MOCK_METHOD1(TagRemoved, void(const dbus::ObjectPath&));
  82   MOCK_METHOD2(TagPropertyChanged, void(const dbus::ObjectPath&,
  83                                         const std::string&));
  84 };
  85
  86 }  // namespace
  87
  88 class NfcClientTest : public testing::Test {
  89  public:
  90   NfcClientTest() : response_(NULL) {}
  91   virtual ~NfcClientTest() {}
  92
  93   virtual void SetUp() override {
  94     // Create the mock bus.
  95     dbus::Bus::Options options;
  96     options.bus_type = dbus::Bus::SYSTEM;
  97     mock_bus_ = new dbus::MockBus(options);
  98
  99     // Create the mock proxies.
 100     mock_manager_proxy_ = new dbus::MockObjectProxy(
 101         mock_bus_.get(),
 102         kTestServiceName,
 103         dbus::ObjectPath(kTestManagerPath));
 104     mock_adapter0_proxy_ = new dbus::MockObjectProxy(
 105         mock_bus_.get(),
 106         kTestServiceName,
 107         dbus::ObjectPath(kTestAdapterPath0));
 108     mock_adapter1_proxy_ = new dbus::MockObjectProxy(
 109         mock_bus_.get(),
 110         kTestServiceName,
 111         dbus::ObjectPath(kTestAdapterPath1));
 112     mock_device0_proxy_ = new dbus::MockObjectProxy(
 113         mock_bus_.get(),
 114         kTestServiceName,
 115         dbus::ObjectPath(kTestDevicePath0));
 116     mock_device1_proxy_ = new dbus::MockObjectProxy(
 117         mock_bus_.get(),
 118         kTestServiceName,
 119         dbus::ObjectPath(kTestDevicePath1));
 120     mock_record0_proxy_ = new dbus::MockObjectProxy(
 121         mock_bus_.get(),
 122         kTestServiceName,
 123         dbus::ObjectPath(kTestRecordPath0));
 124     mock_record1_proxy_ = new dbus::MockObjectProxy(
 125         mock_bus_.get(),
 126         kTestServiceName,
 127         dbus::ObjectPath(kTestRecordPath1));
 128     mock_record2_proxy_ = new dbus::MockObjectProxy(
 129         mock_bus_.get(),
 130         kTestServiceName,
 131         dbus::ObjectPath(kTestRecordPath2));
 132     mock_record3_proxy_ = new dbus::MockObjectProxy(
 133         mock_bus_.get(),
 134         kTestServiceName,
 135         dbus::ObjectPath(kTestRecordPath3));
 136     mock_tag0_proxy_ = new dbus::MockObjectProxy(
 137         mock_bus_.get(),
 138         kTestServiceName,
 139         dbus::ObjectPath(kTestTagPath0));
 140     mock_tag1_proxy_ = new dbus::MockObjectProxy(
 141         mock_bus_.get(),
 142         kTestServiceName,
 143         dbus::ObjectPath(kTestTagPath1));
 144
 145     // Set expectations that use NfcClientTest::OnConnectToSignal when the
 146     // client connect signals on the mock proxies.
 147     EXPECT_CALL(*mock_manager_proxy_.get(), ConnectToSignal(_, _, _, _))
 148         .WillRepeatedly(Invoke(this, &NfcClientTest::OnConnectToSignal));
 149     EXPECT_CALL(*mock_adapter0_proxy_.get(), ConnectToSignal(_, _, _, _))
 150         .WillRepeatedly(Invoke(this, &NfcClientTest::OnConnectToSignal));
 151     EXPECT_CALL(*mock_adapter1_proxy_.get(), ConnectToSignal(_, _, _, _))
 152         .WillRepeatedly(Invoke(this, &NfcClientTest::OnConnectToSignal));
 153
 154     // Set expectations that return our mock proxies on demand.
 155     EXPECT_CALL(
 156         *mock_bus_.get(),
 157         GetObjectProxy(nfc_manager::kNfcManagerServiceName,
 158                        dbus::ObjectPath(nfc_manager::kNfcManagerServicePath)))
 159         .WillRepeatedly(Return(mock_manager_proxy_.get()));
 160     EXPECT_CALL(*mock_bus_.get(),
 161                 GetObjectProxy(nfc_adapter::kNfcAdapterServiceName,
 162                                dbus::ObjectPath(kTestAdapterPath0)))
 163         .WillRepeatedly(Return(mock_adapter0_proxy_.get()));
 164     EXPECT_CALL(*mock_bus_.get(),
 165                 GetObjectProxy(nfc_adapter::kNfcAdapterServiceName,
 166                                dbus::ObjectPath(kTestAdapterPath1)))
 167         .WillRepeatedly(Return(mock_adapter1_proxy_.get()));
 168     EXPECT_CALL(*mock_bus_.get(),
 169                 GetObjectProxy(nfc_device::kNfcDeviceServiceName,
 170                                dbus::ObjectPath(kTestDevicePath0)))
 171         .WillRepeatedly(Return(mock_device0_proxy_.get()));
 172     EXPECT_CALL(*mock_bus_.get(),
 173                 GetObjectProxy(nfc_device::kNfcDeviceServiceName,
 174                                dbus::ObjectPath(kTestDevicePath1)))
 175         .WillRepeatedly(Return(mock_device1_proxy_.get()));
 176     EXPECT_CALL(*mock_bus_.get(),
 177                 GetObjectProxy(nfc_record::kNfcRecordServiceName,
 178                                dbus::ObjectPath(kTestRecordPath0)))
 179         .WillRepeatedly(Return(mock_record0_proxy_.get()));
 180     EXPECT_CALL(*mock_bus_.get(),
 181                 GetObjectProxy(nfc_record::kNfcRecordServiceName,
 182                                dbus::ObjectPath(kTestRecordPath1)))
 183         .WillRepeatedly(Return(mock_record1_proxy_.get()));
 184     EXPECT_CALL(*mock_bus_.get(),
 185                 GetObjectProxy(nfc_record::kNfcRecordServiceName,
 186                                dbus::ObjectPath(kTestRecordPath2)))
 187         .WillRepeatedly(Return(mock_record2_proxy_.get()));
 188     EXPECT_CALL(*mock_bus_.get(),
 189                 GetObjectProxy(nfc_record::kNfcRecordServiceName,
 190                                dbus::ObjectPath(kTestRecordPath3)))
 191         .WillRepeatedly(Return(mock_record3_proxy_.get()));
 192     EXPECT_CALL(*mock_bus_.get(),
 193                 GetObjectProxy(nfc_tag::kNfcTagServiceName,
 194                                dbus::ObjectPath(kTestTagPath0)))
 195         .WillRepeatedly(Return(mock_tag0_proxy_.get()));
 196     EXPECT_CALL(*mock_bus_.get(),
 197                 GetObjectProxy(nfc_tag::kNfcTagServiceName,
 198                                dbus::ObjectPath(kTestTagPath1)))
 199         .WillRepeatedly(Return(mock_tag1_proxy_.get()));
 200
 201     // ShutdownAndBlock will be called in TearDown.
 202     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 203
 204     // Create the clients.
 205     manager_client_.reset(NfcManagerClient::Create());
 206     adapter_client_.reset(NfcAdapterClient::Create(manager_client_.get()));
 207     device_client_.reset(NfcDeviceClient::Create(adapter_client_.get()));
 208     tag_client_.reset(NfcTagClient::Create(adapter_client_.get()));
 209     record_client_.reset(
 210         NfcRecordClient::Create(device_client_.get(), tag_client_.get()));
 211     manager_client_->Init(mock_bus_.get());
 212     adapter_client_->Init(mock_bus_.get());
 213     device_client_->Init(mock_bus_.get());
 214     tag_client_->Init(mock_bus_.get());
 215     record_client_->Init(mock_bus_.get());
 216     manager_client_->AddObserver(&mock_manager_observer_);
 217     adapter_client_->AddObserver(&mock_adapter_observer_);
 218     device_client_->AddObserver(&mock_device_observer_);
 219     tag_client_->AddObserver(&mock_tag_observer_);
 220     record_client_->AddObserver(&mock_record_observer_);
 221
 222     message_loop_.RunUntilIdle();
 223   }
 224
 225   virtual void TearDown() override {
 226     tag_client_->RemoveObserver(&mock_tag_observer_);
 227     device_client_->RemoveObserver(&mock_device_observer_);
 228     adapter_client_->RemoveObserver(&mock_adapter_observer_);
 229     manager_client_->RemoveObserver(&mock_manager_observer_);
 230     mock_bus_->ShutdownAndBlock();
 231   }
 232
 233   void SimulateAdaptersChanged(
 234       const ObjectPathVector& adapter_paths) {
 235     NfcManagerClient::Properties* properties =
 236         manager_client_->GetProperties();
 237     ASSERT_TRUE(properties);
 238     EXPECT_CALL(mock_manager_observer_,
 239                 ManagerPropertyChanged(nfc_manager::kAdaptersProperty));
 240     SendArrayPropertyChangedSignal(
 241         properties,
 242         nfc_manager::kNfcManagerInterface,
 243         nfc_manager::kAdaptersProperty,
 244         adapter_paths);
 245     Mock::VerifyAndClearExpectations(&mock_manager_observer_);
 246   }
 247
 248   void SimulateTagsChanged(const ObjectPathVector& tag_paths,
 249                            const dbus::ObjectPath& adapter_path) {
 250     NfcAdapterClient::Properties* properties =
 251         adapter_client_->GetProperties(adapter_path);
 252     ASSERT_TRUE(properties);
 253     EXPECT_CALL(mock_adapter_observer_,
 254                 AdapterPropertyChanged(adapter_path,
 255                                        nfc_adapter::kTagsProperty));
 256     SendArrayPropertyChangedSignal(
 257         properties,
 258         nfc_adapter::kNfcAdapterInterface,
 259         nfc_adapter::kTagsProperty,
 260         tag_paths);
 261     Mock::VerifyAndClearExpectations(&mock_adapter_observer_);
 262   }
 263
 264   void SimulateDevicesChanged(const ObjectPathVector& device_paths,
 265                               const dbus::ObjectPath& adapter_path) {
 266     NfcAdapterClient::Properties* properties =
 267         adapter_client_->GetProperties(adapter_path);
 268     ASSERT_TRUE(properties);
 269     EXPECT_CALL(mock_adapter_observer_,
 270                 AdapterPropertyChanged(adapter_path,
 271                                        nfc_adapter::kDevicesProperty));
 272     SendArrayPropertyChangedSignal(
 273         properties,
 274         nfc_adapter::kNfcAdapterInterface,
 275         nfc_adapter::kDevicesProperty,
 276         device_paths);
 277     Mock::VerifyAndClearExpectations(&mock_adapter_observer_);
 278   }
 279
 280   void SimulateDeviceRecordsChanged(
 281       const ObjectPathVector& record_paths,
 282       const dbus::ObjectPath& device_path) {
 283     NfcDeviceClient::Properties* properties =
 284         device_client_->GetProperties(device_path);
 285     ASSERT_TRUE(properties);
 286     EXPECT_CALL(mock_device_observer_,
 287                 DevicePropertyChanged(device_path,
 288                                       nfc_device::kRecordsProperty));
 289     SendArrayPropertyChangedSignal(
 290         properties,
 291         nfc_device::kNfcDeviceInterface,
 292         nfc_device::kRecordsProperty,
 293         record_paths);
 294     Mock::VerifyAndClearExpectations(&mock_device_observer_);
 295   }
 296
 297   void SimulateTagRecordsChanged(
 298       const ObjectPathVector& record_paths,
 299       const dbus::ObjectPath& tag_path) {
 300     NfcTagClient::Properties* properties =
 301         tag_client_->GetProperties(tag_path);
 302     ASSERT_TRUE(properties);
 303     EXPECT_CALL(mock_tag_observer_,
 304                 TagPropertyChanged(tag_path,
 305                                    nfc_tag::kRecordsProperty));
 306     SendArrayPropertyChangedSignal(
 307         properties,
 308         nfc_tag::kNfcTagInterface,
 309         nfc_tag::kRecordsProperty,
 310         record_paths);
 311     Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 312   }
 313
 314   void SendArrayPropertyChangedSignal(
 315       dbus::PropertySet* properties,
 316       const std::string& interface,
 317       const std::string& property_name,
 318       ObjectPathVector object_paths) {
 319     dbus::Signal signal(interface, nfc_common::kPropertyChangedSignal);
 320     dbus::MessageWriter writer(&signal);
 321     writer.AppendString(property_name);
 322     dbus::MessageWriter variant_writer(NULL);
 323     writer.OpenVariant("ao", &variant_writer);
 324     variant_writer.AppendArrayOfObjectPaths(object_paths);
 325     writer.CloseContainer(&variant_writer);
 326     properties->ChangedReceived(&signal);
 327   }
 328
 329   MOCK_METHOD0(SuccessCallback, void(void));
 330   MOCK_METHOD2(ErrorCallback, void(const std::string& error_name,
 331                                    const std::string& error_message));
 332
 333  protected:
 334   // The mock object proxies.
 335   scoped_refptr<dbus::MockObjectProxy> mock_manager_proxy_;
 336   scoped_refptr<dbus::MockObjectProxy> mock_adapter0_proxy_;
 337   scoped_refptr<dbus::MockObjectProxy> mock_adapter1_proxy_;
 338   scoped_refptr<dbus::MockObjectProxy> mock_device0_proxy_;
 339   scoped_refptr<dbus::MockObjectProxy> mock_device1_proxy_;
 340   scoped_refptr<dbus::MockObjectProxy> mock_record0_proxy_;
 341   scoped_refptr<dbus::MockObjectProxy> mock_record1_proxy_;
 342   scoped_refptr<dbus::MockObjectProxy> mock_record2_proxy_;
 343   scoped_refptr<dbus::MockObjectProxy> mock_record3_proxy_;
 344   scoped_refptr<dbus::MockObjectProxy> mock_tag0_proxy_;
 345   scoped_refptr<dbus::MockObjectProxy> mock_tag1_proxy_;
 346   // The mock bus.
 347   scoped_refptr<dbus::MockBus> mock_bus_;
 348   // A message loop to emulate asynchronous behavior.
 349   base::MessageLoop message_loop_;
 350   // Response returned by mock methods.
 351   dbus::Response* response_;
 352   // The D-Bus client objects under test.
 353   scoped_ptr<NfcManagerClient> manager_client_;
 354   scoped_ptr<NfcAdapterClient> adapter_client_;
 355   scoped_ptr<NfcDeviceClient> device_client_;
 356   scoped_ptr<NfcTagClient> tag_client_;
 357   scoped_ptr<NfcRecordClient> record_client_;
 358   // Mock observers.
 359   MockNfcManagerObserver mock_manager_observer_;
 360   MockNfcAdapterObserver mock_adapter_observer_;
 361   MockNfcDeviceObserver mock_device_observer_;
 362   MockNfcTagObserver mock_tag_observer_;
 363   MockNfcRecordObserver mock_record_observer_;
 364   // The signal callbacks used to simulate asychronous signals.
 365   dbus::ObjectProxy::SignalCallback manager_adapter_added_signal_callback_;
 366   dbus::ObjectProxy::SignalCallback manager_adapter_removed_signal_callback_;
 367
 368  private:
 369   // Used to implement the mock proxy.
 370   void OnConnectToSignal(
 371       const std::string& interface_name,
 372       const std::string& signal_name,
 373       const dbus::ObjectProxy::SignalCallback& signal_callback,
 374       const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
 375     if (interface_name == nfc_manager::kNfcManagerInterface) {
 376       if (signal_name == nfc_manager::kAdapterAddedSignal)
 377         manager_adapter_added_signal_callback_ = signal_callback;
 378       else if (signal_name == nfc_manager::kAdapterRemovedSignal)
 379         manager_adapter_removed_signal_callback_ = signal_callback;
 380     }
 381     message_loop_.PostTask(FROM_HERE, base::Bind(on_connected_callback,
 382                                                  interface_name,
 383                                                  signal_name,
 384                                                  true));
 385   }
 386 };
 387
 388 // Tests that when adapters are added and removed through the manager, all
 389 // observers are notified and the proxies are created and removed
 390 // accordingly.
 391 TEST_F(NfcClientTest, AdaptersAddedAndRemoved) {
 392   // Invoking methods on adapters that haven't been added should fail.
 393   EXPECT_CALL(*this,
 394               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 395   adapter_client_->StartPollLoop(
 396       dbus::ObjectPath(kTestAdapterPath0),
 397       nfc_adapter::kModeInitiator,
 398       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 399       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 400   Mock::VerifyAndClearExpectations(this);
 401
 402   // Add adapter 0.
 403   ObjectPathVector adapter_paths;
 404   adapter_paths.push_back(dbus::ObjectPath(kTestAdapterPath0));
 405   EXPECT_CALL(mock_adapter_observer_,
 406               AdapterAdded(dbus::ObjectPath(kTestAdapterPath0)));
 407   SimulateAdaptersChanged(adapter_paths);
 408
 409   // Invoking methods should succeed on adapter 0 but fail on adapter 1.
 410   EXPECT_CALL(*mock_adapter0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 411   adapter_client_->StartPollLoop(
 412       dbus::ObjectPath(kTestAdapterPath0),
 413       nfc_adapter::kModeInitiator,
 414       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 415       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 416   Mock::VerifyAndClearExpectations(&mock_adapter0_proxy_);
 417   EXPECT_CALL(*this,
 418               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 419   EXPECT_CALL(*mock_adapter1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 420       .Times(0);
 421   adapter_client_->StartPollLoop(
 422       dbus::ObjectPath(kTestAdapterPath1),
 423       nfc_adapter::kModeInitiator,
 424       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 425       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 426   Mock::VerifyAndClearExpectations(this);
 427   Mock::VerifyAndClearExpectations(&mock_adapter1_proxy_);
 428
 429   // Add adapter 1.
 430   adapter_paths.push_back(dbus::ObjectPath(kTestAdapterPath1));
 431   EXPECT_CALL(mock_adapter_observer_,
 432               AdapterAdded(dbus::ObjectPath(kTestAdapterPath1)));
 433   SimulateAdaptersChanged(adapter_paths);
 434
 435   // Invoking methods should succeed on both adapters.
 436   EXPECT_CALL(*mock_adapter0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 437   EXPECT_CALL(*mock_adapter1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 438   adapter_client_->StartPollLoop(
 439       dbus::ObjectPath(kTestAdapterPath0),
 440       nfc_adapter::kModeInitiator,
 441       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 442       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 443   adapter_client_->StartPollLoop(
 444       dbus::ObjectPath(kTestAdapterPath1),
 445       nfc_adapter::kModeInitiator,
 446       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 447       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 448   Mock::VerifyAndClearExpectations(&mock_adapter0_proxy_);
 449   Mock::VerifyAndClearExpectations(&mock_adapter1_proxy_);
 450
 451   // Remove adapter 0.
 452   adapter_paths.erase(adapter_paths.begin());
 453   EXPECT_CALL(mock_adapter_observer_,
 454               AdapterRemoved(dbus::ObjectPath(kTestAdapterPath0)));
 455   SimulateAdaptersChanged(adapter_paths);
 456
 457   // Invoking methods should succeed on adapter 1 but fail on adapter 0.
 458   EXPECT_CALL(*this,
 459               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 460   EXPECT_CALL(*mock_adapter0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 461       .Times(0);
 462   adapter_client_->StartPollLoop(
 463       dbus::ObjectPath(kTestAdapterPath0),
 464       nfc_adapter::kModeInitiator,
 465       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 466       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 467   Mock::VerifyAndClearExpectations(this);
 468
 469   EXPECT_CALL(*mock_adapter1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 470   adapter_client_->StartPollLoop(
 471       dbus::ObjectPath(kTestAdapterPath1),
 472       nfc_adapter::kModeInitiator,
 473       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 474       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 475   Mock::VerifyAndClearExpectations(&mock_adapter0_proxy_);
 476   Mock::VerifyAndClearExpectations(&mock_adapter1_proxy_);
 477
 478   // Remove adapter 1.
 479   adapter_paths.clear();
 480   EXPECT_CALL(mock_adapter_observer_,
 481               AdapterRemoved(dbus::ObjectPath(kTestAdapterPath1)));
 482   SimulateAdaptersChanged(adapter_paths);
 483
 484   // Invoking methods should fail on both adapters.
 485   EXPECT_CALL(*this,
 486               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _))
 487       .Times(2);
 488   EXPECT_CALL(*mock_adapter0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 489       .Times(0);
 490   EXPECT_CALL(*mock_adapter1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 491       .Times(0);
 492   adapter_client_->StartPollLoop(
 493       dbus::ObjectPath(kTestAdapterPath0),
 494       nfc_adapter::kModeInitiator,
 495       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 496       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 497   adapter_client_->StartPollLoop(
 498       dbus::ObjectPath(kTestAdapterPath1),
 499       nfc_adapter::kModeInitiator,
 500       base::Bind(&NfcClientTest::SuccessCallback, base::Unretained(this)),
 501       base::Bind(&NfcClientTest::ErrorCallback, base::Unretained(this)));
 502 }
 503
 504 // Tests that when tags are added and removed through an adapter, all
 505 // observers are notified and the proxies are created and removed
 506 // accordingly.
 507 TEST_F(NfcClientTest, TagsAddedAndRemoved) {
 508   // Invoking methods on tags that haven't been added should fail.
 509   EXPECT_CALL(*this,
 510               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 511   base::DictionaryValue write_data;
 512   write_data.SetString(nfc_record::kTypeProperty, nfc_record::kTypeText);
 513   tag_client_->Write(dbus::ObjectPath(kTestTagPath0), write_data,
 514                      base::Bind(&NfcClientTest::SuccessCallback,
 515                                 base::Unretained(this)),
 516                      base::Bind(&NfcClientTest::ErrorCallback,
 517                                 base::Unretained(this)));
 518   Mock::VerifyAndClearExpectations(this);
 519
 520   // Add adapter 0.
 521   ObjectPathVector adapter_paths;
 522   adapter_paths.push_back(dbus::ObjectPath(kTestAdapterPath0));
 523   EXPECT_CALL(mock_adapter_observer_,
 524               AdapterAdded(dbus::ObjectPath(kTestAdapterPath0)));
 525   SimulateAdaptersChanged(adapter_paths);
 526   Mock::VerifyAndClearExpectations(&mock_adapter_observer_);
 527
 528   // Add tag 0.
 529   ObjectPathVector tag_paths;
 530   tag_paths.push_back(dbus::ObjectPath(kTestTagPath0));
 531   EXPECT_CALL(mock_tag_observer_,
 532               TagAdded(dbus::ObjectPath(kTestTagPath0)));
 533   SimulateTagsChanged(tag_paths, dbus::ObjectPath(kTestAdapterPath0));
 534   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 535
 536   // Invoking methods should succeed on tag 0 but fail on tag 1.
 537   EXPECT_CALL(*mock_tag0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 538   tag_client_->Write(dbus::ObjectPath(kTestTagPath0), write_data,
 539                      base::Bind(&NfcClientTest::SuccessCallback,
 540                                 base::Unretained(this)),
 541                      base::Bind(&NfcClientTest::ErrorCallback,
 542                                 base::Unretained(this)));
 543   Mock::VerifyAndClearExpectations(&mock_tag0_proxy_);
 544   EXPECT_CALL(*this,
 545               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 546   EXPECT_CALL(*mock_tag1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 547       .Times(0);
 548   tag_client_->Write(dbus::ObjectPath(kTestTagPath1), write_data,
 549                      base::Bind(&NfcClientTest::SuccessCallback,
 550                                 base::Unretained(this)),
 551                      base::Bind(&NfcClientTest::ErrorCallback,
 552                                 base::Unretained(this)));
 553   Mock::VerifyAndClearExpectations(this);
 554   Mock::VerifyAndClearExpectations(&mock_tag1_proxy_);
 555
 556   // Add tag 1.
 557   tag_paths.push_back(dbus::ObjectPath(kTestTagPath1));
 558   EXPECT_CALL(mock_tag_observer_,
 559               TagAdded(dbus::ObjectPath(kTestTagPath1)));
 560   SimulateTagsChanged(tag_paths, dbus::ObjectPath(kTestAdapterPath0));
 561   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 562
 563   // Invoking methods should succeed on both tags.
 564   EXPECT_CALL(*mock_tag0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 565   EXPECT_CALL(*mock_tag1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 566   tag_client_->Write(dbus::ObjectPath(kTestTagPath0), write_data,
 567                      base::Bind(&NfcClientTest::SuccessCallback,
 568                                 base::Unretained(this)),
 569                      base::Bind(&NfcClientTest::ErrorCallback,
 570                                 base::Unretained(this)));
 571   tag_client_->Write(dbus::ObjectPath(kTestTagPath1), write_data,
 572                      base::Bind(&NfcClientTest::SuccessCallback,
 573                                 base::Unretained(this)),
 574                      base::Bind(&NfcClientTest::ErrorCallback,
 575                                 base::Unretained(this)));
 576   Mock::VerifyAndClearExpectations(&mock_tag0_proxy_);
 577   Mock::VerifyAndClearExpectations(&mock_tag1_proxy_);
 578
 579   // Remove tag 0.
 580   tag_paths.erase(tag_paths.begin());
 581   EXPECT_CALL(mock_tag_observer_,
 582               TagRemoved(dbus::ObjectPath(kTestTagPath0)));
 583   SimulateTagsChanged(tag_paths, dbus::ObjectPath(kTestAdapterPath0));
 584   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 585
 586   // Invoking methods should succeed on tag 1 but fail on tag 0.
 587   EXPECT_CALL(*this,
 588               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 589   EXPECT_CALL(*mock_tag0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 590       .Times(0);
 591   tag_client_->Write(dbus::ObjectPath(kTestTagPath0), write_data,
 592                      base::Bind(&NfcClientTest::SuccessCallback,
 593                                 base::Unretained(this)),
 594                      base::Bind(&NfcClientTest::ErrorCallback,
 595                                 base::Unretained(this)));
 596   Mock::VerifyAndClearExpectations(this);
 597   Mock::VerifyAndClearExpectations(&mock_tag0_proxy_);
 598   EXPECT_CALL(*mock_tag1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 599   tag_client_->Write(dbus::ObjectPath(kTestTagPath1), write_data,
 600                      base::Bind(&NfcClientTest::SuccessCallback,
 601                                 base::Unretained(this)),
 602                      base::Bind(&NfcClientTest::ErrorCallback,
 603                                 base::Unretained(this)));
 604   Mock::VerifyAndClearExpectations(&mock_tag1_proxy_);
 605
 606   // Remove tag 1.
 607   tag_paths.clear();
 608   EXPECT_CALL(mock_tag_observer_,
 609               TagRemoved(dbus::ObjectPath(kTestTagPath1)));
 610   SimulateTagsChanged(tag_paths, dbus::ObjectPath(kTestAdapterPath0));
 611   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 612
 613   // Invoking methods should fail on both tags.
 614   EXPECT_CALL(*this,
 615               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _))
 616       .Times(2);
 617   EXPECT_CALL(*mock_tag0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 618       .Times(0);
 619   EXPECT_CALL(*mock_tag1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 620       .Times(0);
 621   tag_client_->Write(dbus::ObjectPath(kTestTagPath0), write_data,
 622                      base::Bind(&NfcClientTest::SuccessCallback,
 623                                 base::Unretained(this)),
 624                      base::Bind(&NfcClientTest::ErrorCallback,
 625                                 base::Unretained(this)));
 626   tag_client_->Write(dbus::ObjectPath(kTestTagPath1), write_data,
 627                      base::Bind(&NfcClientTest::SuccessCallback,
 628                                 base::Unretained(this)),
 629                      base::Bind(&NfcClientTest::ErrorCallback,
 630                                 base::Unretained(this)));
 631 }
 632
 633 // Tests that when devices are added and removed through an adapter, all
 634 // observers are notified and the proxies are created and removed
 635 // accordingly.
 636 TEST_F(NfcClientTest, DevicesAddedAndRemoved) {
 637   // Invoking methods on devices that haven't been added should fail.
 638   EXPECT_CALL(*this,
 639               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 640   base::DictionaryValue write_data;
 641   write_data.SetString(nfc_record::kTypeProperty, nfc_record::kTypeText);
 642   device_client_->Push(dbus::ObjectPath(kTestDevicePath0), write_data,
 643                        base::Bind(&NfcClientTest::SuccessCallback,
 644                                   base::Unretained(this)),
 645                        base::Bind(&NfcClientTest::ErrorCallback,
 646                                   base::Unretained(this)));
 647   Mock::VerifyAndClearExpectations(this);
 648
 649   // Add adapter 0.
 650   ObjectPathVector adapter_paths;
 651   adapter_paths.push_back(dbus::ObjectPath(kTestAdapterPath0));
 652   EXPECT_CALL(mock_adapter_observer_,
 653               AdapterAdded(dbus::ObjectPath(kTestAdapterPath0)));
 654   SimulateAdaptersChanged(adapter_paths);
 655
 656   // Add device 0.
 657   ObjectPathVector device_paths;
 658   device_paths.push_back(dbus::ObjectPath(kTestDevicePath0));
 659   EXPECT_CALL(mock_device_observer_,
 660               DeviceAdded(dbus::ObjectPath(kTestDevicePath0)));
 661   SimulateDevicesChanged(device_paths, dbus::ObjectPath(kTestAdapterPath0));
 662   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 663
 664   // Invoking methods should succeed on device 0 but fail on device 1.
 665   EXPECT_CALL(*mock_device0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 666   device_client_->Push(dbus::ObjectPath(kTestDevicePath0), write_data,
 667                        base::Bind(&NfcClientTest::SuccessCallback,
 668                                   base::Unretained(this)),
 669                        base::Bind(&NfcClientTest::ErrorCallback,
 670                                   base::Unretained(this)));
 671   Mock::VerifyAndClearExpectations(&mock_device0_proxy_);
 672   EXPECT_CALL(*this,
 673               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 674   EXPECT_CALL(*mock_device1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 675       .Times(0);
 676   device_client_->Push(dbus::ObjectPath(kTestDevicePath1), write_data,
 677                        base::Bind(&NfcClientTest::SuccessCallback,
 678                                   base::Unretained(this)),
 679                        base::Bind(&NfcClientTest::ErrorCallback,
 680                                   base::Unretained(this)));
 681   Mock::VerifyAndClearExpectations(this);
 682   Mock::VerifyAndClearExpectations(&mock_device1_proxy_);
 683
 684   // Add device 1.
 685   device_paths.push_back(dbus::ObjectPath(kTestDevicePath1));
 686   EXPECT_CALL(mock_device_observer_,
 687               DeviceAdded(dbus::ObjectPath(kTestDevicePath1)));
 688   SimulateDevicesChanged(device_paths, dbus::ObjectPath(kTestAdapterPath0));
 689   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 690
 691   // Invoking methods should succeed on both devices.
 692   EXPECT_CALL(*mock_device0_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 693   EXPECT_CALL(*mock_device1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 694   device_client_->Push(dbus::ObjectPath(kTestDevicePath0), write_data,
 695                        base::Bind(&NfcClientTest::SuccessCallback,
 696                                   base::Unretained(this)),
 697                        base::Bind(&NfcClientTest::ErrorCallback,
 698                                   base::Unretained(this)));
 699   device_client_->Push(dbus::ObjectPath(kTestDevicePath1), write_data,
 700                        base::Bind(&NfcClientTest::SuccessCallback,
 701                                   base::Unretained(this)),
 702                        base::Bind(&NfcClientTest::ErrorCallback,
 703                                   base::Unretained(this)));
 704   Mock::VerifyAndClearExpectations(&mock_device0_proxy_);
 705   Mock::VerifyAndClearExpectations(&mock_device1_proxy_);
 706
 707   // Remove device 0.
 708   device_paths.erase(device_paths.begin());
 709   EXPECT_CALL(mock_device_observer_,
 710               DeviceRemoved(dbus::ObjectPath(kTestDevicePath0)));
 711   SimulateDevicesChanged(device_paths, dbus::ObjectPath(kTestAdapterPath0));
 712   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 713
 714   // Invoking methods should succeed on device 1 but fail on device 0.
 715   EXPECT_CALL(*this,
 716               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _));
 717   EXPECT_CALL(*mock_device0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 718       .Times(0);
 719   device_client_->Push(dbus::ObjectPath(kTestDevicePath0), write_data,
 720                        base::Bind(&NfcClientTest::SuccessCallback,
 721                                   base::Unretained(this)),
 722                        base::Bind(&NfcClientTest::ErrorCallback,
 723                                   base::Unretained(this)));
 724   Mock::VerifyAndClearExpectations(this);
 725   Mock::VerifyAndClearExpectations(&mock_device0_proxy_);
 726   EXPECT_CALL(*mock_device1_proxy_, CallMethodWithErrorCallback(_, _, _, _));
 727   device_client_->Push(dbus::ObjectPath(kTestDevicePath1), write_data,
 728                        base::Bind(&NfcClientTest::SuccessCallback,
 729                                   base::Unretained(this)),
 730                        base::Bind(&NfcClientTest::ErrorCallback,
 731                                   base::Unretained(this)));
 732   Mock::VerifyAndClearExpectations(&mock_device1_proxy_);
 733
 734   // Remove device 1.
 735   device_paths.clear();
 736   EXPECT_CALL(mock_device_observer_,
 737               DeviceRemoved(dbus::ObjectPath(kTestDevicePath1)));
 738   SimulateDevicesChanged(device_paths, dbus::ObjectPath(kTestAdapterPath0));
 739   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 740
 741   // Invoking methods should fail on both devices.
 742   EXPECT_CALL(*this,
 743               ErrorCallback(nfc_client_helpers::kUnknownObjectError, _))
 744       .Times(2);
 745   EXPECT_CALL(*mock_device0_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 746       .Times(0);
 747   EXPECT_CALL(*mock_device1_proxy_, CallMethodWithErrorCallback(_, _, _, _))
 748       .Times(0);
 749   device_client_->Push(dbus::ObjectPath(kTestDevicePath0), write_data,
 750                        base::Bind(&NfcClientTest::SuccessCallback,
 751                                   base::Unretained(this)),
 752                        base::Bind(&NfcClientTest::ErrorCallback,
 753                                   base::Unretained(this)));
 754   device_client_->Push(dbus::ObjectPath(kTestDevicePath1), write_data,
 755                        base::Bind(&NfcClientTest::SuccessCallback,
 756                                   base::Unretained(this)),
 757                        base::Bind(&NfcClientTest::ErrorCallback,
 758                                   base::Unretained(this)));
 759 }
 760
 761 TEST_F(NfcClientTest, ObjectCleanup) {
 762   // Tests that when an adapter gets removed, proxies that belong to the
 763   // adapter, device, tag, and record hierarchy get cleaned up properly.
 764   ObjectPathVector object_paths;
 765
 766   // Add adapters.
 767   EXPECT_CALL(mock_adapter_observer_,
 768               AdapterAdded(dbus::ObjectPath(kTestAdapterPath0)));
 769   EXPECT_CALL(mock_adapter_observer_,
 770               AdapterAdded(dbus::ObjectPath(kTestAdapterPath1)));
 771   object_paths.push_back(dbus::ObjectPath(kTestAdapterPath0));
 772   object_paths.push_back(dbus::ObjectPath(kTestAdapterPath1));
 773   SimulateAdaptersChanged(object_paths);
 774   Mock::VerifyAndClearExpectations(&mock_adapter_observer_);
 775
 776   // Add devices and a tags. Assign them like the following:
 777   //  - device 0 -> adapter 0
 778   //  - tag 0 -> adapter 0
 779   //  - device 1 -> adapter 1
 780   //  - tag 1 -> adapter 1
 781   EXPECT_CALL(mock_device_observer_,
 782               DeviceAdded(dbus::ObjectPath(kTestDevicePath0)));
 783   EXPECT_CALL(mock_device_observer_,
 784               DeviceAdded(dbus::ObjectPath(kTestDevicePath1)));
 785   EXPECT_CALL(mock_tag_observer_,
 786               TagAdded(dbus::ObjectPath(kTestTagPath0)));
 787   EXPECT_CALL(mock_tag_observer_,
 788               TagAdded(dbus::ObjectPath(kTestTagPath1)));
 789   object_paths.clear();
 790   object_paths.push_back(dbus::ObjectPath(kTestDevicePath0));
 791   SimulateDevicesChanged(object_paths, dbus::ObjectPath(kTestAdapterPath0));
 792   object_paths.clear();
 793   object_paths.push_back(dbus::ObjectPath(kTestTagPath0));
 794   SimulateTagsChanged(object_paths, dbus::ObjectPath(kTestAdapterPath0));
 795   object_paths.clear();
 796   object_paths.push_back(dbus::ObjectPath(kTestDevicePath1));
 797   SimulateDevicesChanged(object_paths, dbus::ObjectPath(kTestAdapterPath1));
 798   object_paths.clear();
 799   object_paths.push_back(dbus::ObjectPath(kTestTagPath1));
 800   SimulateTagsChanged(object_paths, dbus::ObjectPath(kTestAdapterPath1));
 801   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 802   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 803
 804   // Add records. Assign them like the following:
 805   //  - record 0 -> device 0
 806   //  - record 1 -> tag 0
 807   //  - record 2 -> device 1
 808   //  - record 3 -> tag 1
 809   EXPECT_CALL(mock_record_observer_,
 810               RecordAdded(dbus::ObjectPath(kTestRecordPath0)));
 811   EXPECT_CALL(mock_record_observer_,
 812               RecordAdded(dbus::ObjectPath(kTestRecordPath1)));
 813   EXPECT_CALL(mock_record_observer_,
 814               RecordAdded(dbus::ObjectPath(kTestRecordPath2)));
 815   EXPECT_CALL(mock_record_observer_,
 816               RecordAdded(dbus::ObjectPath(kTestRecordPath3)));
 817   object_paths.clear();
 818   object_paths.push_back(dbus::ObjectPath(kTestRecordPath0));
 819   SimulateDeviceRecordsChanged(object_paths,
 820                                dbus::ObjectPath(kTestDevicePath0));
 821   object_paths.clear();
 822   object_paths.push_back(dbus::ObjectPath(kTestRecordPath1));
 823   SimulateTagRecordsChanged(object_paths,
 824                             dbus::ObjectPath(kTestTagPath0));
 825   object_paths.clear();
 826   object_paths.push_back(dbus::ObjectPath(kTestRecordPath2));
 827   SimulateDeviceRecordsChanged(object_paths,
 828                                dbus::ObjectPath(kTestDevicePath1));
 829   object_paths.clear();
 830   object_paths.push_back(dbus::ObjectPath(kTestRecordPath3));
 831   SimulateTagRecordsChanged(object_paths,
 832                             dbus::ObjectPath(kTestTagPath1));
 833   Mock::VerifyAndClearExpectations(&mock_record_observer_);
 834
 835   // Check that the records have been assigned to the correct device or tag.
 836   NfcTagClient::Properties* tag_properties =
 837       tag_client_->GetProperties(dbus::ObjectPath(kTestTagPath0));
 838   EXPECT_EQ((size_t)1, tag_properties->records.value().size());
 839   EXPECT_EQ(dbus::ObjectPath(kTestRecordPath1),
 840             tag_properties->records.value()[0]);
 841   NfcDeviceClient::Properties* device_properties =
 842       device_client_->GetProperties(dbus::ObjectPath(kTestDevicePath0));
 843   EXPECT_EQ((size_t)1, device_properties->records.value().size());
 844   EXPECT_EQ(dbus::ObjectPath(kTestRecordPath0),
 845             device_properties->records.value()[0]);
 846
 847   // Remove adapter 0. Make sure that all of the tag, device, and records that
 848   // are in the adapter 0 hierarchy are removed.
 849   object_paths.clear();
 850   object_paths.push_back(dbus::ObjectPath(kTestAdapterPath1));
 851   EXPECT_CALL(mock_adapter_observer_,
 852               AdapterRemoved(dbus::ObjectPath(kTestAdapterPath0)));
 853   EXPECT_CALL(mock_device_observer_,
 854               DeviceRemoved(dbus::ObjectPath(kTestDevicePath0)));
 855   EXPECT_CALL(mock_tag_observer_,
 856               TagRemoved(dbus::ObjectPath(kTestTagPath0)));
 857   EXPECT_CALL(mock_record_observer_,
 858               RecordRemoved(dbus::ObjectPath(kTestRecordPath0)));
 859   EXPECT_CALL(mock_record_observer_,
 860               RecordRemoved(dbus::ObjectPath(kTestRecordPath1)));
 861   SimulateAdaptersChanged(object_paths);
 862   Mock::VerifyAndClearExpectations(&mock_adapter_observer_);
 863   Mock::VerifyAndClearExpectations(&mock_device_observer_);
 864   Mock::VerifyAndClearExpectations(&mock_tag_observer_);
 865   Mock::VerifyAndClearExpectations(&mock_record_observer_);
 866
 867   // Remove adapter 1.
 868   object_paths.clear();
 869   EXPECT_CALL(mock_adapter_observer_,
 870               AdapterRemoved(dbus::ObjectPath(kTestAdapterPath1)));
 871   EXPECT_CALL(mock_device_observer_,
 872               DeviceRemoved(dbus::ObjectPath(kTestDevicePath1)));
 873   EXPECT_CALL(mock_tag_observer_,
 874               TagRemoved(dbus::ObjectPath(kTestTagPath1)));
 875   EXPECT_CALL(mock_record_observer_,
 876               RecordRemoved(dbus::ObjectPath(kTestRecordPath2)));
 877   EXPECT_CALL(mock_record_observer_,
 878               RecordRemoved(dbus::ObjectPath(kTestRecordPath3)));
 879   SimulateAdaptersChanged(object_paths);
 880 }
 881
 882 }  // namespace chromeos