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