service/test/gatt_client_unittest.cc

   1 //
   2 //  Copyright 2015 Google, Inc.
   3 //
   4 //  Licensed under the Apache License, Version 2.0 (the "License");
   5 //  you may not use this file except in compliance with the License.
   6 //  You may obtain a copy of the License at:
   7 //
   8 //  http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 //  Unless required by applicable law or agreed to in writing, software
  11 //  distributed under the License is distributed on an "AS IS" BASIS,
  12 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 //  See the License for the specific language governing permissions and
  14 //  limitations under the License.
  15 //
  16
  17 #include <base/macros.h>
  18 #include <gmock/gmock.h>
  19 #include <gtest/gtest.h>
  20
  21 #include "service/gatt_client.h"
  22 #include "service/hal/fake_bluetooth_gatt_interface.h"
  23
  24 using ::testing::_;
  25 using ::testing::Return;
  26
  27 namespace bluetooth {
  28 namespace {
  29
  30 class MockGattHandler
  31     : public hal::FakeBluetoothGattInterface::TestClientHandler {
  32  public:
  33   MockGattHandler() = default;
  34   ~MockGattHandler() override = default;
  35
  36   MOCK_METHOD1(RegisterClient, bt_status_t(const bluetooth::Uuid&));
  37   MOCK_METHOD1(UnregisterClient, bt_status_t(int));
  38   MOCK_METHOD1(Scan, bt_status_t(bool));
  39   MOCK_METHOD4(Connect, bt_status_t(int, const RawAddress&, bool, int));
  40   MOCK_METHOD3(Disconnect, bt_status_t(int, const RawAddress&, int));
  41
  42  private:
  43   DISALLOW_COPY_AND_ASSIGN(MockGattHandler);
  44 };
  45
  46 class GattClientTest : public ::testing::Test {
  47  public:
  48   GattClientTest() = default;
  49   ~GattClientTest() override = default;
  50
  51   void SetUp() override {
  52     // Only set |mock_handler_| if a previous test case hasn't set it.
  53     if (!mock_handler_) mock_handler_.reset(new MockGattHandler());
  54
  55     fake_hal_gatt_iface_ = new hal::FakeBluetoothGattInterface(
  56         nullptr, nullptr,
  57         std::static_pointer_cast<
  58             hal::FakeBluetoothGattInterface::TestClientHandler>(mock_handler_),
  59         nullptr);
  60     hal::BluetoothGattInterface::InitializeForTesting(fake_hal_gatt_iface_);
  61
  62     factory_.reset(new GattClientFactory());
  63   }
  64
  65   void TearDown() override {
  66     factory_.reset();
  67     hal::BluetoothGattInterface::CleanUp();
  68   }
  69
  70  protected:
  71   hal::FakeBluetoothGattInterface* fake_hal_gatt_iface_;
  72   std::shared_ptr<MockGattHandler> mock_handler_;
  73   std::unique_ptr<GattClientFactory> factory_;
  74
  75  private:
  76   DISALLOW_COPY_AND_ASSIGN(GattClientTest);
  77 };
  78
  79 TEST_F(GattClientTest, RegisterInstance) {
  80   EXPECT_CALL(*mock_handler_, RegisterClient(_))
  81       .Times(2)
  82       .WillOnce(Return(BT_STATUS_FAIL))
  83       .WillOnce(Return(BT_STATUS_SUCCESS));
  84
  85   // These will be asynchronously populated with a result when the callback
  86   // executes.
  87   BLEStatus status = BLE_STATUS_SUCCESS;
  88   Uuid cb_uuid;
  89   std::unique_ptr<GattClient> client;
  90   int callback_count = 0;
  91
  92   auto callback = [&](BLEStatus in_status, const Uuid& uuid,
  93                       std::unique_ptr<BluetoothInstance> in_client) {
  94     status = in_status;
  95     cb_uuid = uuid;
  96     client = std::unique_ptr<GattClient>(
  97         static_cast<GattClient*>(in_client.release()));
  98     callback_count++;
  99   };
 100
 101   Uuid uuid0 = Uuid::GetRandom();
 102
 103   // HAL returns failure.
 104   EXPECT_FALSE(factory_->RegisterInstance(uuid0, callback));
 105   EXPECT_EQ(0, callback_count);
 106
 107   // HAL returns success.
 108   EXPECT_TRUE(factory_->RegisterInstance(uuid0, callback));
 109   EXPECT_EQ(0, callback_count);
 110
 111   // Calling twice with the same Uuid should fail with no additional call into
 112   // the stack.
 113   EXPECT_FALSE(factory_->RegisterInstance(uuid0, callback));
 114
 115   testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
 116
 117   // Call with a different Uuid while one is pending.
 118   Uuid uuid1 = Uuid::GetRandom();
 119   EXPECT_CALL(*mock_handler_, RegisterClient(_))
 120       .Times(1)
 121       .WillOnce(Return(BT_STATUS_SUCCESS));
 122   EXPECT_TRUE(factory_->RegisterInstance(uuid1, callback));
 123
 124   // Trigger callback with an unknown Uuid. This should get ignored.
 125   Uuid uuid2 = Uuid::GetRandom();
 126   fake_hal_gatt_iface_->NotifyRegisterClientCallback(0, 0, uuid2);
 127   EXPECT_EQ(0, callback_count);
 128
 129   // |uuid0| succeeds.
 130   int client_id0 = 2;  // Pick something that's not 0.
 131   fake_hal_gatt_iface_->NotifyRegisterClientCallback(BT_STATUS_SUCCESS,
 132                                                      client_id0, uuid0);
 133
 134   EXPECT_EQ(1, callback_count);
 135   ASSERT_TRUE(client.get() != nullptr);  // Assert to terminate in case of error
 136   EXPECT_EQ(BLE_STATUS_SUCCESS, status);
 137   EXPECT_EQ(client_id0, client->GetInstanceId());
 138   EXPECT_EQ(uuid0, client->GetAppIdentifier());
 139   EXPECT_EQ(uuid0, cb_uuid);
 140
 141   // The client should unregister itself when deleted.
 142   EXPECT_CALL(*mock_handler_, UnregisterClient(client_id0))
 143       .Times(1)
 144       .WillOnce(Return(BT_STATUS_SUCCESS));
 145   client.reset();
 146   testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
 147
 148   // |uuid1| fails.
 149   int client_id1 = 3;
 150   fake_hal_gatt_iface_->NotifyRegisterClientCallback(BT_STATUS_FAIL, client_id1,
 151                                                      uuid1);
 152
 153   EXPECT_EQ(2, callback_count);
 154   ASSERT_TRUE(client.get() == nullptr);  // Assert to terminate in case of error
 155   EXPECT_EQ(BLE_STATUS_FAILURE, status);
 156   EXPECT_EQ(uuid1, cb_uuid);
 157 }
 158
 159 }  // namespace
 160 }  // namespace bluetooth