src/extensions/browser/api/bluetooth/bluetooth_private_apitest.cc

   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