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:
BluetoothPrivateApiTest()42 BluetoothPrivateApiTest()
43 : adapter_name_(kAdapterName),
44 adapter_powered_(false),
45 adapter_discoverable_(false) {}
46
~BluetoothPrivateApiTest()47 virtual ~BluetoothPrivateApiTest() {}
48
SetUpOnMainThread()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
TearDownOnMainThread()65 virtual void TearDownOnMainThread() OVERRIDE {}
66
event_router()67 BluetoothEventRouter* event_router() {
68 return BluetoothAPI::Get(browser()->profile())->event_router();
69 }
70
SetName(const std::string & name,const base::Closure & callback)71 void SetName(const std::string& name, const base::Closure& callback) {
72 adapter_name_ = name;
73 callback.Run();
74 }
75
SetPowered(bool powered,const base::Closure & callback)76 void SetPowered(bool powered, const base::Closure& callback) {
77 adapter_powered_ = powered;
78 callback.Run();
79 }
80
SetDiscoverable(bool discoverable,const base::Closure & callback)81 void SetDiscoverable(bool discoverable, const base::Closure& callback) {
82 adapter_discoverable_ = discoverable;
83 callback.Run();
84 }
85
DispatchPairingEvent(bt_private::PairingEventType pairing_event_type)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
DispatchAuthorizePairingEvent()102 void DispatchAuthorizePairingEvent() {
103 DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTAUTHORIZATION);
104 }
105
DispatchPincodePairingEvent()106 void DispatchPincodePairingEvent() {
107 DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPINCODE);
108 }
109
DispatchPasskeyPairingEvent()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
IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest,SetAdapterState)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
IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest,NoBluetoothAdapter)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
IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest,CancelPairing)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
IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest,PincodePairing)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
IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest,PasskeyPairing)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