Add unit test for ArcBluetoothBridge and TypeConverter

components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc

Index: components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc
diff --git a/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc b/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b4c9f80d82e5e5a4ab669c0d7515b5b460d465f6
--- /dev/null
+++ b/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc
@@ -0,0 +1,221 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/arc/bluetooth/arc_bluetooth_bridge.h"
+
+#include <string>
+#include <vector>
+
+#include "components/arc/bluetooth/bluetooth_type_converters.h"
+#include "components/arc/common/bluetooth.mojom.h"
+#include "components/arc/test/fake_arc_bridge_service.h"
+#include "components/arc/test/fake_bluetooth_instance.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/test/mock_bluetooth_device.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_descriptor.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
+#include "mojo/public/cpp/bindings/array.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace arc {
+
+namespace {
+
+const char kAddressStr[] = "1A:2B:3C:4D:5E:6F";

[rkc, 2016/06/19 18:45:43]

constexpr everywhere.

+const char kDeviceName[] = "DeviceName";
+const uint32_t kDeviceClass = 0x2580;
+const int16_t kDeviceRssi = -45;
+const char kServiceID[] = "/org/bluez/hci0/dev_1A_2B_3C_4D_5E_6F/service180f";
+const char kServiceUUID[] = "180f";
+const char kCharID[] =
+    "/org/bluez/hci0/dev_1A_2B_3C_4D_5E_6F/service180f/char2a19";
+const char kCharUUID[] = "2a19";
+const uint16_t kCharUUIDInt = 0x2a19;
+
+class FakeArcBluetoothBridge : public ArcBluetoothBridge {
+ public:
+  FakeArcBluetoothBridge(ArcBridgeService* bridge_service,
+                         device::MockBluetoothAdapter* adapter)
+      : ArcBluetoothBridge(bridge_service, true /* test_flag */) {
+    SetAdapterForTest(adapter);
+  }
+
+  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {}
+};
+
+}  // namespace
+
+class ArcBluetoothBridgeTest : public testing::Test {
+ public:
+  ArcBluetoothBridgeTest() {}
+
+ protected:
+  FakeArcBridgeService* fake_arc_bridge_service_;
+  FakeArcBluetoothBridge* fake_arc_bluetooth_bridge_;
+  FakeBluetoothInstance* fake_bluetooth_instance;
+  device::MockBluetoothAdapter* fake_adapter_;
+  device::MockBluetoothDevice* fake_device_;
+  device::MockBluetoothGattService* fake_service_;
+  device::MockBluetoothGattCharacteristic* fake_char_;
+  std::vector<device::BluetoothUUID> device_uuids_;
+
+  mojom::BluetoothAddressPtr remote_addr;
+  mojom::BluetoothGattServiceIDPtr service_id;
+  mojom::BluetoothGattIDPtr char_id;
+
+ private:
+  void SetUp() override {
+    fake_arc_bridge_service_ = new FakeArcBridgeService();
+
+    fake_adapter_ = new testing::NiceMock<device::MockBluetoothAdapter>();
+    fake_arc_bluetooth_bridge_ =
+        new FakeArcBluetoothBridge(fake_arc_bridge_service_, fake_adapter_);
+
+    fake_device_ = new testing::NiceMock<device::MockBluetoothDevice>(
+        fake_adapter_, 0 /* bluetooth_class */, kDeviceName, kAddressStr,
+        false /* paired */, false /* connected */);
+    ON_CALL(*fake_device_, GetBluetoothClass())
+        .WillByDefault(testing::Return(kDeviceClass));
+    ON_CALL(*fake_device_, GetInquiryRSSI())
+        .WillByDefault(testing::Return(kDeviceRssi));
+
+    device_uuids_.emplace_back(device::BluetoothUUID(kServiceUUID));
+    device_uuids_.emplace_back(device::BluetoothUUID(kCharUUID));
+    ON_CALL(*fake_device_, GetUUIDs())
+        .WillByDefault(testing::Return(device_uuids_));
+
+    fake_adapter_->AddMockDevice(base::WrapUnique(fake_device_));
+    ON_CALL(*fake_adapter_, GetDevices())
+        .WillByDefault(testing::Return(fake_adapter_->GetConstMockDevices()));
+    ON_CALL(*fake_adapter_, GetDevice("1A:2B:3C:4D:5E:6F"))
+        .WillByDefault(testing::Return(fake_device_));
+
+    fake_service_ = new testing::NiceMock<device::MockBluetoothGattService>(
+        fake_device_, kServiceID, device::BluetoothUUID(kServiceUUID),
+        true /* is_primary */, true /* is_local */);
+    fake_device_->AddMockService(base::WrapUnique(fake_service_));
+    ON_CALL(*fake_device_, GetGattServices())
+        .WillByDefault(testing::Return(fake_device_->GetMockServices()));
+
+    fake_char_ = new testing::NiceMock<device::MockBluetoothGattCharacteristic>(
+        fake_service_, kCharID, device::BluetoothUUID(kCharUUID),
+        true /*is_local*/, device::BluetoothGattCharacteristic::PROPERTY_READ,
+        device::BluetoothGattCharacteristic::PERMISSION_READ);
+    fake_service_->AddMockCharacteristic(base::WrapUnique(fake_char_));
+    ON_CALL(*fake_service_, GetCharacteristics())
+        .WillByDefault(
+            testing::Return(fake_service_->GetMockCharacteristics()));
+
+    remote_addr = mojom::BluetoothAddress::From(std::string(kAddressStr));
+
+    service_id = mojom::BluetoothGattServiceID::New();
+    service_id->is_primary = true;
+    service_id->id = mojom::BluetoothGattID::New();
+    service_id->id->inst_id = 0;
+    service_id->id->uuid =
+        mojom::BluetoothUUID::From(device::BluetoothUUID(kServiceUUID));
+
+    char_id = mojom::BluetoothGattID::New();
+    char_id->inst_id = 0;
+    char_id->uuid =
+        mojom::BluetoothUUID::From(device::BluetoothUUID(kCharUUID));
+
+    mojom::BluetoothInstancePtr bluetooth_instance_ptr;
+    fake_bluetooth_instance = new FakeBluetoothInstance();
+    fake_arc_bluetooth_bridge_->SetBluetoothInstanceForTest(
+        fake_bluetooth_instance);
+  }
+
+  void TearDown() override {
+    fake_arc_bluetooth_bridge_->SetAdapterForTest(nullptr);
+    fake_arc_bluetooth_bridge_->SetBluetoothInstanceForTest(nullptr);
+    delete fake_arc_bridge_service_;
+  }
+};
+
+// Invoke OnDiscoveryStarted to send cached device to BT instance,
+// and check correctness of the device properties sent via arc bridge.
+TEST_F(ArcBluetoothBridgeTest, DeviceFound) {
+  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
+
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance->device_found_data().size());
+  const mojo::Array<mojom::BluetoothPropertyPtr>& prop =
+      fake_bluetooth_instance->device_found_data().back();
+
+  EXPECT_EQ((size_t)7, prop.size());
+  EXPECT_TRUE(prop[0]->is_bdname());
+  EXPECT_EQ(std::string(kDeviceName), prop[0]->get_bdname());
+  EXPECT_TRUE(prop[1]->is_bdaddr());
+  EXPECT_EQ(std::string(kAddressStr), prop[1]->get_bdaddr()->To<std::string>());
+  EXPECT_TRUE(prop[2]->is_uuids());
+  EXPECT_EQ(device_uuids_,
+            prop[2]->get_uuids().To<std::vector<device::BluetoothUUID>>());
+  EXPECT_TRUE(prop[3]->is_device_class());
+  EXPECT_EQ(kDeviceClass, prop[3]->get_device_class());
+  EXPECT_TRUE(prop[4]->is_device_type());
+  EXPECT_EQ(mojom::BluetoothDeviceType::DUAL, prop[4]->get_device_type());
+  EXPECT_TRUE(prop[5]->is_remote_friendly_name());
+  EXPECT_EQ(std::string(kDeviceName), prop[5]->get_remote_friendly_name());
+  EXPECT_TRUE(prop[6]->is_remote_rssi());
+  EXPECT_EQ(kDeviceRssi, prop[6]->get_remote_rssi());
+}
+
+// Invoke OnDiscoveryStarted to send cached device to BT instance,
+// and check correctness of the Advertising data sent via arc bridge.
+TEST_F(ArcBluetoothBridgeTest, LEDeviceFound) {
+  // Check that we check bluetooth_instance version correctly.
+  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
+  EXPECT_EQ((size_t)0, fake_bluetooth_instance->le_device_found_data().size());
+
+  fake_arc_bluetooth_bridge_->SetBluetoothVersionForTest(1);
+  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance->le_device_found_data().size());
+
+  const mojom::BluetoothAddressPtr& addr =
+      fake_bluetooth_instance->le_device_found_data().back()->addr();
+  int32_t rssi = fake_bluetooth_instance->le_device_found_data().back()->rssi();
+  const mojo::Array<mojom::BluetoothAdvertisingDataPtr>& adv_data =
+      fake_bluetooth_instance->le_device_found_data().back()->adv_data();
+
+  EXPECT_EQ(std::string(kAddressStr), addr->To<std::string>());
+  EXPECT_EQ(kDeviceRssi, rssi);
+  EXPECT_EQ((size_t)1, adv_data.size());
+
+  EXPECT_TRUE(adv_data[0]->is_local_name());
+  EXPECT_EQ(std::string(kDeviceName),
+            adv_data[0]->get_local_name().To<std::string>());
+}
+
+// Invoke GetGattDB and check correctness of the GattDB sent via arc bridge.
+TEST_F(ArcBluetoothBridgeTest, GetGattDB) {
+  fake_arc_bluetooth_bridge_->GetGattDB(remote_addr.Clone());
+
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance->gatt_db_result().size());
+
+  const mojom::BluetoothAddressPtr& addr =
+      fake_bluetooth_instance->gatt_db_result().back()->remote_addr();
+  const mojo::Array<mojom::BluetoothGattDBElementPtr>& db =
+      fake_bluetooth_instance->gatt_db_result().back()->db();
+
+  EXPECT_EQ(std::string(kAddressStr), addr->To<std::string>());
+  EXPECT_EQ((size_t)2, db.size());
+
+  EXPECT_EQ(device::BluetoothUUID(kServiceUUID),
+            db[0]->uuid.To<device::BluetoothUUID>());
+  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE,
+            db[0]->type);
+  EXPECT_EQ(kCharUUIDInt, db[0]->start_handle);
+  EXPECT_EQ(kCharUUIDInt, db[0]->end_handle);
+
+  EXPECT_EQ(device::BluetoothUUID(kCharUUID),
+            db[1]->uuid.To<device::BluetoothUUID>());
+  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
+            db[1]->type);
+  EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_READ,
+            db[1]->properties);
+}
+
+}  // namespace arc