Home | History | Annotate | Download | only in bluetooth 
      1 // Copyright 2014 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/command_line.h"
      6 #include "base/memory/ref_counted.h"
      7 #include "base/memory/scoped_ptr.h"
      8 #include "chrome/browser/extensions/extension_apitest.h"
      9 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
     10 #include "device/bluetooth/test/mock_bluetooth_device.h"
     11 #include "extensions/browser/api/bluetooth/bluetooth_api.h"
     12 #include "extensions/browser/api/bluetooth/bluetooth_event_router.h"
     13 #include "extensions/browser/event_router.h"
     14 #include "extensions/common/api/bluetooth_private.h"
     15 #include "extensions/common/switches.h"
     16 #include "testing/gmock/include/gmock/gmock.h"
     17 
     18 using device::MockBluetoothAdapter;
     19 using device::MockBluetoothDevice;
     20 using testing::_;
     21 using testing::InSequence;
     22 using testing::NiceMock;
     23 using testing::Return;
     24 using testing::ReturnPointee;
     25 using testing::WithArgs;
     26 using testing::WithoutArgs;
     27 
     28 namespace bt = extensions::core_api::bluetooth;
     29 namespace bt_private = extensions::core_api::bluetooth_private;
     30 
     31 namespace extensions {
     32 
     33 namespace {
     34 
     35 const char kTestExtensionId[] = "jofgjdphhceggjecimellaapdjjadibj";
     36 const char kAdapterName[] = "Helix";
     37 const char kDeviceName[] = "Red";
     38 }
     39 
     40 class BluetoothPrivateApiTest : public ExtensionApiTest {
     41  public:
     42   BluetoothPrivateApiTest()
     43       : adapter_name_(kAdapterName),
     44         adapter_powered_(false),
     45         adapter_discoverable_(false) {}
     46 
     47   virtual ~BluetoothPrivateApiTest() {}
     48 
     49   virtual void SetUpOnMainThread() OVERRIDE {
     50     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
     51         switches::kWhitelistedExtensionID, kTestExtensionId);
     52     mock_adapter_ = new NiceMock<MockBluetoothAdapter>();
     53     event_router()->SetAdapterForTest(mock_adapter_.get());
     54     mock_device_.reset(new NiceMock<MockBluetoothDevice>(mock_adapter_.get(),
     55                                                          0,
     56                                                          kDeviceName,
     57                                                          "11:12:13:14:15:16",
     58                                                          false,
     59                                                          false));
     60     ON_CALL(*mock_adapter_.get(), GetDevice(mock_device_->GetAddress()))
     61         .WillByDefault(Return(mock_device_.get()));
     62     ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(true));
     63   }
     64 
     65   virtual void TearDownOnMainThread() OVERRIDE {}
     66 
     67   BluetoothEventRouter* event_router() {
     68     return BluetoothAPI::Get(browser()->profile())->event_router();
     69   }
     70 
     71   void SetName(const std::string& name, const base::Closure& callback) {
     72     adapter_name_ = name;
     73     callback.Run();
     74   }
     75 
     76   void SetPowered(bool powered, const base::Closure& callback) {
     77     adapter_powered_ = powered;
     78     callback.Run();
     79   }
     80 
     81   void SetDiscoverable(bool discoverable, const base::Closure& callback) {
     82     adapter_discoverable_ = discoverable;
     83     callback.Run();
     84   }
     85 
     86   void DispatchPairingEvent(bt_private::PairingEventType pairing_event_type) {
     87     bt_private::PairingEvent pairing_event;
     88     pairing_event.pairing = pairing_event_type;
     89     pairing_event.device.name.reset(new std::string(kDeviceName));
     90     pairing_event.device.address = mock_device_->GetAddress();
     91     pairing_event.device.vendor_id_source = bt::VENDOR_ID_SOURCE_USB;
     92     pairing_event.device.type = bt::DEVICE_TYPE_PHONE;
     93 
     94     scoped_ptr<base::ListValue> args =
     95         bt_private::OnPairing::Create(pairing_event);
     96     scoped_ptr<Event> event(
     97         new Event(bt_private::OnPairing::kEventName, args.Pass()));
     98     EventRouter::Get(browser()->profile())->DispatchEventToExtension(
     99         kTestExtensionId, event.Pass());
    100   }
    101 
    102   void DispatchAuthorizePairingEvent() {
    103     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTAUTHORIZATION);
    104   }
    105 
    106   void DispatchPincodePairingEvent() {
    107     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPINCODE);
    108   }
    109 
    110   void DispatchPasskeyPairingEvent() {
    111     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPASSKEY);
    112   }
    113 
    114  protected:
    115   std::string adapter_name_;
    116   bool adapter_powered_;
    117   bool adapter_discoverable_;
    118 
    119   scoped_refptr<NiceMock<MockBluetoothAdapter> > mock_adapter_;
    120   scoped_ptr<NiceMock<MockBluetoothDevice> > mock_device_;
    121 };
    122 
    123 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, SetAdapterState) {
    124   ON_CALL(*mock_adapter_.get(), GetName())
    125       .WillByDefault(ReturnPointee(&adapter_name_));
    126   ON_CALL(*mock_adapter_.get(), IsPowered())
    127       .WillByDefault(ReturnPointee(&adapter_powered_));
    128   ON_CALL(*mock_adapter_.get(), IsDiscoverable())
    129       .WillByDefault(ReturnPointee(&adapter_discoverable_));
    130 
    131   EXPECT_CALL(*mock_adapter_.get(), SetName("Dome", _, _)).WillOnce(
    132       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetName)));
    133   EXPECT_CALL(*mock_adapter_.get(), SetPowered(true, _, _)).WillOnce(
    134       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetPowered)));
    135   EXPECT_CALL(*mock_adapter_.get(), SetDiscoverable(true, _, _)).WillOnce(
    136       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetDiscoverable)));
    137 
    138   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/adapter_state"))
    139       << message_;
    140 }
    141 
    142 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, NoBluetoothAdapter) {
    143   ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(false));
    144   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/no_adapter"))
    145       << message_;
    146 }
    147 
    148 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, CancelPairing) {
    149   InSequence s;
    150   EXPECT_CALL(*mock_adapter_.get(),
    151               AddPairingDelegate(
    152                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
    153       .WillOnce(WithoutArgs(Invoke(
    154           this, &BluetoothPrivateApiTest::DispatchAuthorizePairingEvent)));
    155   EXPECT_CALL(*mock_device_, ExpectingConfirmation())
    156       .WillRepeatedly(Return(true));
    157   EXPECT_CALL(*mock_device_, CancelPairing());
    158   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/cancel_pairing"))
    159       << message_;
    160 }
    161 
    162 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, PincodePairing) {
    163   EXPECT_CALL(*mock_adapter_.get(),
    164               AddPairingDelegate(
    165                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
    166       .WillOnce(WithoutArgs(
    167           Invoke(this, &BluetoothPrivateApiTest::DispatchPincodePairingEvent)));
    168   EXPECT_CALL(*mock_device_, ExpectingPinCode()).WillRepeatedly(Return(true));
    169   EXPECT_CALL(*mock_device_, SetPinCode("abbbbbbk"));
    170   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/pincode_pairing"))
    171       << message_;
    172 }
    173 
    174 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, PasskeyPairing) {
    175   EXPECT_CALL(*mock_adapter_.get(),
    176               AddPairingDelegate(
    177                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
    178       .WillOnce(WithoutArgs(
    179           Invoke(this, &BluetoothPrivateApiTest::DispatchPasskeyPairingEvent)));
    180   EXPECT_CALL(*mock_device_, ExpectingPasskey()).WillRepeatedly(Return(true));
    181   EXPECT_CALL(*mock_device_, SetPasskey(900531));
    182   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/passkey_pairing"))
    183       << message_;
    184 }
    185 
    186 }  // namespace extensions
    187