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 18using device::MockBluetoothAdapter; 19using device::MockBluetoothDevice; 20using testing::_; 21using testing::InSequence; 22using testing::NiceMock; 23using testing::Return; 24using testing::ReturnPointee; 25using testing::WithArgs; 26using testing::WithoutArgs; 27 28namespace bt = extensions::core_api::bluetooth; 29namespace bt_private = extensions::core_api::bluetooth_private; 30 31namespace extensions { 32 33namespace { 34 35const char kTestExtensionId[] = "jofgjdphhceggjecimellaapdjjadibj"; 36const char kAdapterName[] = "Helix"; 37const char kDeviceName[] = "Red"; 38} 39 40class 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 123IN_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 142IN_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 148IN_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 162IN_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 174IN_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