Substituting legacy protocol with uWeave protocol

components/proximity_auth/ble/bluetooth_low_energy_weave_client_connection_unittest.cc

 // Copyright 2015 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/proximity_auth/ble/bluetooth_low_energy_connection.h"
+#include "components/proximity_auth/ble/bluetooth_low_energy_weave_client_connection.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
-#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
-#include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::SaveArg;
 
 namespace proximity_auth {
 namespace {
 
+class MockBluetoothThrottler : public BluetoothThrottler {
+ public:
+  MockBluetoothThrottler() {}
+  ~MockBluetoothThrottler() override {}
+
+  MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
+  MOCK_METHOD1(OnConnection, void(Connection* connection));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockBluetoothThrottler);
+};
+
+class MockBluetoothLowEnergyCharacteristicsFinder
+    : public BluetoothLowEnergyCharacteristicsFinder {
+ public:
+  MockBluetoothLowEnergyCharacteristicsFinder() {}
+  ~MockBluetoothLowEnergyCharacteristicsFinder() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyCharacteristicsFinder);
+};
+
+}  // namespace
+
+namespace weave {
+namespace {
+
+typedef BluetoothLowEnergyWeaveClientConnection::SubStatus SubStatus;
+typedef BluetoothLowEnergyWeavePacketReceiver::State ReceiverState;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverError ReceiverError;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverType ReceiverType;
+
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
-const char kToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
-const char kFromPeripheralCharUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
+const char kTXCharacteristicUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
+const char kRXCharacteristicUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
 
 const char kServiceID[] = "service id";
-const char kToPeripheralCharID[] = "to peripheral char id";
-const char kFromPeripheralCharID[] = "from peripheral char id";
+const char kTXCharacteristicID[] = "TX characteristic id";
+const char kRXCharacteristicID[] = "RX characteristic id";
 
 const device::BluetoothRemoteGattCharacteristic::Properties
     kCharacteristicProperties =
         device::BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST |
         device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
         device::BluetoothRemoteGattCharacteristic::
             PROPERTY_WRITE_WITHOUT_RESPONSE |
         device::BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE;
 
 const int kMaxNumberOfTries = 3;
+const uint16_t kLargeMaxPacketSize = 30;
 
-class MockBluetoothThrottler : public BluetoothThrottler {
+const uint8_t kDataHeader = 0;
+const uint8_t kConnectionRequestHeader = 1;
+const uint8_t kSmallConnectionResponseHeader = 2;
+const uint8_t kLargeConnectionResponseHeader = 3;
+
+const std::string kSmallMessage = "bb";
+const std::string kLargeMessage = "aaabbb";
+
+const Packet kConnectionRequest{kConnectionRequestHeader};
+const Packet kSmallConnectionResponse{kSmallConnectionResponseHeader};
+const Packet kLargeConnectionResponse{kLargeConnectionResponseHeader};
+
+const std::vector<Packet> kSmallPackets{Packet{kDataHeader, 'b', 'b'}};

[Kyle Horimoto, 2016/06/30 01:29:48]

Create a constant for each Packet so that they can be referenced below.

[jingxuy, 2016/06/30 21:59:25]

Done.

+const std::vector<Packet> kLargePackets{Packet{kDataHeader, 'a', 'a', 'a'},
+                                        Packet{kDataHeader, 'b', 'b', 'b'}};
+
+class MockBluetoothLowEnergyWeavePacketGenerator
+    : public BluetoothLowEnergyWeavePacketGenerator {
  public:
-  MockBluetoothThrottler() {}
-  ~MockBluetoothThrottler() override {}
+  MockBluetoothLowEnergyWeavePacketGenerator()
+      : max_packet_size_(kDefaultMaxPacketSize) {}
 
-  MOCK_CONST_METHOD0(GetDelay, base::TimeDelta());
-  MOCK_METHOD1(OnConnection, void(Connection* connection));
+  Packet CreateConnectionRequest() override { return kConnectionRequest; }
+
+  Packet CreateConnectionResponse() override {

[Kyle Horimoto, 2016/06/30 01:29:48]

This function should never be called by the client. Just replace the
implementation with NOTIMPLEMENTED().

[jingxuy, 2016/06/30 21:59:25]

Done.

+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      DLOG(ERROR) << "getting small";

[Kyle Horimoto, 2016/06/30 01:29:48]

Please remove these logs. Alternatively, make the log messages descriptive and
log them to INFO instead of ERROR.

Same elsewhere in this test.

[jingxuy, 2016/06/30 21:59:25]

It's already done in the most recent version.

+      return kSmallConnectionResponse;
+    } else {
+      DLOG(ERROR) << "getting large";
+      return kLargeConnectionResponse;
+    }
+  }
+
+  Packet CreateConnectionClose(ReasonForClose reason_for_close) override {
+    return Packet{static_cast<uint8_t>(reason_for_close)};

[Kyle Horimoto, 2016/06/30 01:29:48]

You should use a special header for this just as you did for the others.
Otherwise, what if someone sets the "reason for close" to 0, 1, 2, or 3? Your
message would be indistinguishable from the other message types you defined
above.

[jingxuy, 2016/06/30 21:59:26]

Done.

+  }
+
+  void SetMaxPacketSize(uint16_t size) override {
+    DLOG(ERROR) << "\n"
+                << "Setting generator packet size" << size << "\n";
+    max_packet_size_ = size;
+  }
+
+  std::vector<Packet> EncodeDataMessage(std::string message) override {

[Kyle Horimoto, 2016/06/30 01:29:48]

Please add some string constants which correspond to the Packets which are
returned. Otherwise, |message| is ignored.

For example, you could have a string "smallMessage" which results in
|kSmallPackets| being returned; likewise with "largeMessage".

[jingxuy, 2016/06/30 21:59:25]

Done.

+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      return kSmallPackets;
+    } else {
+      return kLargePackets;
+    }
+  }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothThrottler);
+  uint16_t max_packet_size_;

[Kyle Horimoto, 2016/06/30 01:29:48]

Add a getter for this so that you can test that when a connection response is
received with a certain data packet size, you can get it and assert that it is
correct.

[jingxuy, 2016/06/30 21:59:26]

I replied in a comment below. A getter is not going to work. This can be a
static variable instead. But I think this is implicitly tested by small/large
test.

[Kyle Horimoto, 2016/06/30 22:36:11]

Please test this explicitly. You should create a new mock generator/receiver in
each test and share the reference between the test and the implementation so
that the implementation makes calls on the generator/receiver and the test can
make assertions on them.

[jingxuy, 2016/07/01 00:00:44]

Done.

 };
 
-class MockBluetoothLowEnergyCharacteristicsFinder
-    : public BluetoothLowEnergyCharacteristicsFinder {
+class MockBluetoothLowEnergyWeavePacketReceiver
+    : public BluetoothLowEnergyWeavePacketReceiver {
  public:
-  MockBluetoothLowEnergyCharacteristicsFinder() {}
-  ~MockBluetoothLowEnergyCharacteristicsFinder() override {}
+  MockBluetoothLowEnergyWeavePacketReceiver()
+      : BluetoothLowEnergyWeavePacketReceiver(ReceiverType::CLIENT),
+        state_(State::CONNECTING),
+        max_packet_size_(kDefaultMaxPacketSize) {}
+
+  ReceiverState GetState() override { return state_; }
+
+  uint16_t GetMaxPacketSize() override { return max_packet_size_; }
+
+  ReasonForClose GetReasonForClose() override {
+    return ReasonForClose::CLOSE_WITHOUT_ERROR;

[Kyle Horimoto, 2016/06/30 01:29:48]

Don't just return a constant. Add a setter for this and the two getters below so
that you can set them in your test.

[jingxuy, 2016/07/01 00:00:44]

Done.

+  }
+
+  ReasonForClose GetReasonToClose() override {
+    return ReasonForClose::UNKNOWN_ERROR;
+  }
+
+  std::string GetDataMessage() override {
+    if (max_packet_size_ == kDefaultMaxPacketSize) {
+      return kSmallMessage;
+    } else {
+      return kLargeMessage;
+    }
+  }
+
+  ReceiverError GetReceiverError() override {
+    return ReceiverError::NO_ERROR_DETECTED;
+  }
+
+  ReceiverState ReceivePacket(const Packet& packet) override {
+    for (auto chr : packet) {
+      DLOG(ERROR) << chr;
+    }
+    switch (packet[0]) {
+      case kSmallConnectionResponseHeader:
+        max_packet_size_ = kDefaultMaxPacketSize;
+        state_ = ReceiverState::WAITING;
+        break;
+      case kLargeConnectionResponseHeader:
+        max_packet_size_ = kLargeMaxPacketSize;
+        state_ = ReceiverState::WAITING;
+        break;
+      case kDataHeader:
+        if (packet[1] == 'b') {

[Kyle Horimoto, 2016/06/30 01:29:48]

Check the entire packet for equality instead of one character.

[jingxuy, 2016/06/30 21:59:26]

Done.

+          state_ = ReceiverState::DATA_READY;
+        } else {
+          state_ = ReceiverState::RECEIVING_DATA;
+        }
+        break;
+      default:
+        NOTREACHED();
+    }
+    return state_;
+  }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyCharacteristicsFinder);
+  ReceiverState state_;
+  uint16_t max_packet_size_;
 };
 
-class MockBluetoothLowEnergyConnection : public BluetoothLowEnergyConnection {
+class MockBluetoothLowEnergyWeavePacketGeneratorFactory
+    : public BluetoothLowEnergyWeavePacketGenerator::Factory {
+ private:

[Kyle Horimoto, 2016/06/30 01:29:48]

Why is this private? Same below.

[jingxuy, 2016/06/30 21:59:25]

it only need to be called from the factory class. It was protected initially so
that it can be inherited. now there is no point of inhereiting

+  std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> BuildInstance()
+      override {
+    return std::unique_ptr<MockBluetoothLowEnergyWeavePacketGenerator>(
+        new MockBluetoothLowEnergyWeavePacketGenerator());
+  }
+};
+
+class MockBluetoothLowEnergyWeavePacketReceiverFactory
+    : public BluetoothLowEnergyWeavePacketReceiver::Factory {
+ private:
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> BuildInstance(
+      ReceiverType receiver_type) override {
+    return std::unique_ptr<MockBluetoothLowEnergyWeavePacketReceiver>(
+        new MockBluetoothLowEnergyWeavePacketReceiver());
+  }
+};
+
+class TestBluetoothLowEnergyWeaveClientConnection
+    : public BluetoothLowEnergyWeaveClientConnection {
  public:
-  MockBluetoothLowEnergyConnection(
+  TestBluetoothLowEnergyWeaveClientConnection(
       const RemoteDevice& remote_device,
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID remote_service_uuid,
       BluetoothThrottler* bluetooth_throttler,
       int max_number_of_write_attempts)
-      : BluetoothLowEnergyConnection(remote_device,
-                                     adapter,
-                                     remote_service_uuid,
-                                     bluetooth_throttler,
-                                     max_number_of_write_attempts) {}
+      : BluetoothLowEnergyWeaveClientConnection(remote_device,
+                                                adapter,
+                                                remote_service_uuid,
+                                                bluetooth_throttler,
+                                                max_number_of_write_attempts) {}
 
-  ~MockBluetoothLowEnergyConnection() override {}
+  ~TestBluetoothLowEnergyWeaveClientConnection() override {}
 
   MOCK_METHOD2(
       CreateCharacteristicsFinder,
       BluetoothLowEnergyCharacteristicsFinder*(
           const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
               success,
           const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback& error));
 
   MOCK_METHOD2(OnDidSendMessage,
                void(const WireMessage& message, bool success));
   MOCK_METHOD1(OnBytesReceived, void(const std::string& bytes));
 
   // Exposing inherited protected methods for testing.
-  using BluetoothLowEnergyConnection::GattCharacteristicValueChanged;
-  using BluetoothLowEnergyConnection::SetTaskRunnerForTesting;
+  using BluetoothLowEnergyWeaveClientConnection::GattCharacteristicValueChanged;
+  using BluetoothLowEnergyWeaveClientConnection::SetTaskRunnerForTesting;
 
   // Exposing inherited protected fields for testing.
-  using BluetoothLowEnergyConnection::status;
-  using BluetoothLowEnergyConnection::sub_status;
+  using BluetoothLowEnergyWeaveClientConnection::status;
+  using BluetoothLowEnergyWeaveClientConnection::sub_status;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyConnection);
+  DISALLOW_COPY_AND_ASSIGN(TestBluetoothLowEnergyWeaveClientConnection);
 };
 
 }  // namespace
 
-class ProximityAuthBluetoothLowEnergyConnectionTest : public testing::Test {
+class ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest
+    : public testing::Test {
  public:
-  ProximityAuthBluetoothLowEnergyConnectionTest()
+  ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
         remote_device_(CreateLERemoteDeviceForTest()),
         service_uuid_(device::BluetoothUUID(kServiceUUID)),
-        to_peripheral_char_uuid_(device::BluetoothUUID(kToPeripheralCharUUID)),
-        from_peripheral_char_uuid_(
-            device::BluetoothUUID(kFromPeripheralCharUUID)),
+        tx_characteristic_uuid_(device::BluetoothUUID(kTXCharacteristicUUID)),
+        rx_characteristic_uuid_(device::BluetoothUUID(kRXCharacteristicUUID)),
         notify_session_alias_(NULL),
         bluetooth_throttler_(new NiceMock<MockBluetoothThrottler>),
         task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     device_ = base::WrapUnique(new NiceMock<device::MockBluetoothDevice>(
         adapter_.get(), 0, kTestRemoteDeviceName,
         kTestRemoteDeviceBluetoothAddress, false, false));
 
     service_ = base::WrapUnique(new NiceMock<device::MockBluetoothGattService>(
         device_.get(), kServiceID, service_uuid_, true, false));
-    to_peripheral_char_ =
+    tx_characteristic_ =
         base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
-            service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
-            false, kCharacteristicProperties,
+            service_.get(), kTXCharacteristicID, tx_characteristic_uuid_, false,
+            kCharacteristicProperties,
             device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
-    from_peripheral_char_ =
+    rx_characteristic_ =
         base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
-            service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
-            false, kCharacteristicProperties,
+            service_.get(), kRXCharacteristicID, rx_characteristic_uuid_, false,
+            kCharacteristicProperties,
             device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
 
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     std::vector<const device::BluetoothDevice*> devices;
     devices.push_back(device_.get());
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
     ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(device_.get()));
     ON_CALL(*device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
-    ON_CALL(*service_, GetCharacteristic(kFromPeripheralCharID))
-        .WillByDefault(Return(from_peripheral_char_.get()));
-    ON_CALL(*service_, GetCharacteristic(kToPeripheralCharID))
-        .WillByDefault(Return(to_peripheral_char_.get()));
+    ON_CALL(*service_, GetCharacteristic(kRXCharacteristicID))
+        .WillByDefault(Return(rx_characteristic_.get()));
+    ON_CALL(*service_, GetCharacteristic(kTXCharacteristicID))
+        .WillByDefault(Return(tx_characteristic_.get()));
   }
 
-  // Creates a BluetoothLowEnergyConnection and verifies it's in DISCONNECTED
-  // state.
-  std::unique_ptr<MockBluetoothLowEnergyConnection> CreateConnection() {
+  // Creates a BluetoothLowEnergyWeaveClientConnection and verifies it's in
+  // DISCONNECTED state.
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection>
+  CreateConnection() {
     EXPECT_CALL(*adapter_, AddObserver(_));
     EXPECT_CALL(*adapter_, RemoveObserver(_));
 
-    std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
-        new MockBluetoothLowEnergyConnection(
+    BluetoothLowEnergyWeavePacketGenerator::Factory::SetInstanceForTesting(

[Kyle Horimoto, 2016/06/30 01:29:48]

These should be moved to SetUp().

[jingxuy, 2016/06/30 21:59:26]

I moved them to the constructor since they only needed to be called once.

[Kyle Horimoto, 2016/06/30 22:36:11]

You should create a new instance of the generator/receiver for each test so that
you can call getters on these instances in order to assert behavior.

[jingxuy, 2016/07/01 00:00:44]

instance of generator/receiver is still unique to each test. This is merely just
injecting a factory that is only needed once.

+        &generator_factory_);
+    BluetoothLowEnergyWeavePacketReceiver::Factory::SetInstanceForTesting(
+        &receiver_factory_);
+
+    std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
+        new TestBluetoothLowEnergyWeaveClientConnection(
             remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
             kMaxNumberOfTries));
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+    EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
     EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 
     connection->SetTaskRunnerForTesting(task_runner_);
 
     return connection;
   }
 
   // Transitions |connection| from DISCONNECTED to WAITING_CHARACTERISTICS
   // state, without an existing GATT connection.
-  void ConnectGatt(MockBluetoothLowEnergyConnection* connection) {
+  void ConnectGatt(TestBluetoothLowEnergyWeaveClientConnection* connection) {
     // Preparing |connection| for a CreateGattConnection call.
     EXPECT_CALL(*device_, CreateGattConnection(_, _))
         .WillOnce(DoAll(SaveArg<0>(&create_gatt_connection_success_callback_),
                         SaveArg<1>(&create_gatt_connection_error_callback_)));
 
     // No throttling by default
     EXPECT_CALL(*bluetooth_throttler_, GetDelay())
         .WillOnce(Return(base::TimeDelta()));
 
     connection->Connect();
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_GATT_CONNECTION);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_GATT_CONNECTION);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
 
     // Preparing |connection| to run |create_gatt_connection_success_callback_|.
     EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
     ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
     EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
         .WillOnce(DoAll(
             SaveArg<0>(&characteristics_finder_success_callback_),
             SaveArg<1>(&characteristics_finder_error_callback_),
             Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
     create_gatt_connection_success_callback_.Run(
         base::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
             adapter_, kTestRemoteDeviceBluetoothAddress)));
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_CHARACTERISTICS);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_CHARACTERISTICS);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_CHARACTERISTICS to
   // WAITING_NOTIFY_SESSION state.
-  void CharacteristicsFound(MockBluetoothLowEnergyConnection* connection) {
-    EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _))
+  void CharacteristicsFound(
+      TestBluetoothLowEnergyWeaveClientConnection* connection) {
+    EXPECT_CALL(*rx_characteristic_, StartNotifySession(_, _))
         .WillOnce(DoAll(SaveArg<0>(&notify_session_success_callback_),
                         SaveArg<1>(&notify_session_error_callback_)));
     EXPECT_FALSE(characteristics_finder_error_callback_.is_null());
     ASSERT_FALSE(characteristics_finder_success_callback_.is_null());
 
     characteristics_finder_success_callback_.Run(
         {service_uuid_, kServiceID},
-        {to_peripheral_char_uuid_, kToPeripheralCharID},
-        {from_peripheral_char_uuid_, kFromPeripheralCharID});
+        {tx_characteristic_uuid_, kTXCharacteristicID},
+        {rx_characteristic_uuid_, kRXCharacteristicID});
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_NOTIFY_SESSION);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_NOTIFY_SESSION);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_NOTIFY_SESSION to
-  // WAITING_RESPONSE_SIGNAL state.
-  void NotifySessionStarted(MockBluetoothLowEnergyConnection* connection) {
-    EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  // WAITING_CONNECTION_RESPONSE state.
+  void NotifySessionStarted(
+      TestBluetoothLowEnergyWeaveClientConnection* connection) {
+    EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
         .WillOnce(
-            DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+            DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                   SaveArg<1>(&write_remote_characteristic_success_callback_),
                   SaveArg<2>(&write_remote_characteristic_error_callback_)));
     EXPECT_FALSE(notify_session_error_callback_.is_null());
     ASSERT_FALSE(notify_session_success_callback_.is_null());
 
     // Store an alias for the notify session passed |connection|.
     std::unique_ptr<device::MockBluetoothGattNotifySession> notify_session(
         new NiceMock<device::MockBluetoothGattNotifySession>(
-            kToPeripheralCharID));
+            kTXCharacteristicID));
     notify_session_alias_ = notify_session.get();
 
     notify_session_success_callback_.Run(std::move(notify_session));
     task_runner_->RunUntilIdle();
 

[Kyle Horimoto, 2016/06/30 01:29:48]

Assert that a connection request was sent.

[jingxuy, 2016/06/30 21:59:26]

what do you mean? the expect_call on tx_characteristic_ already does that

[Kyle Horimoto, 2016/06/30 22:36:11]

Where? It looks like it only asserts that WriteRemoteCharacteristic() was
called, not that a connection request was sent. Just move this line from
ConnectionResponseReceived() here instead:

EXPECT_EQ(last_value_written_on_tx_characteristic_, kConnectionRequest);

[jingxuy, 2016/07/01 00:00:44]

It's kind of weird because this function merely stores
last_value_written_on_tx_characteristic_ but it's other functions's
responsibility to test the value of it. If a connection request is sent, this
value is tested in WriteRemoteCharacteristic(). But it's not the only instance,
it can also be called before a disconnect. I didn't dig too deep into other
tests but it seems like the current implementation is fine.

[Kyle Horimoto, 2016/07/01 17:23:21]

Please test this explicitly here. Some tests call NotifySessionStarted() without
calling ConnectionResponseReceived(), so we should not rely on this happening to
test this. It is a testing best practice to explicitly test interactions between
the class under test and the other objects which have been injected instead of
relying on implicit interactions.

[jingxuy, 2016/07/01 19:28:08]

Done.

-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::WAITING_RESPONSE_SIGNAL);
+    EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_CONNECTION_RESPONSE);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
-  // Transitions |connection| from WAITING_RESPONSE_SIGNAL to CONNECTED state.
-  void ResponseSignalReceived(MockBluetoothLowEnergyConnection* connection) {
-    // Written value contains only the
-    // BluetoothLowEneryConnection::ControlSignal::kInviteToConnectSignal.
-    const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
-        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
-                                  kInviteToConnectSignal));
-    EXPECT_EQ(last_value_written_on_to_peripheral_char_,
-              kInviteToConnectSignal);
+  // Transitions |connection| from WAITING_CONNECTION_RESPONSE to CONNECTED.
+  void ConnectionResponseReceived(
+      TestBluetoothLowEnergyWeaveClientConnection* connection,
+      uint16_t selected_packet_size) {
+    // Written value contains only the mock Connection Request.
+    EXPECT_EQ(last_value_written_on_tx_characteristic_, kConnectionRequest);
 
     EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
     RunWriteCharacteristicSuccessCallback();
 
-    // Received the
-    // BluetoothLowEneryConnection::ControlSignal::kInvitationResponseSignal.
-    const std::vector<uint8_t> kInvitationResponseSignal = ToByteVector(
-        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
-                                  kInvitationResponseSignal));
-    connection->GattCharacteristicValueChanged(
-        adapter_.get(), from_peripheral_char_.get(), kInvitationResponseSignal);
+    // Received Connection Response.
+    if (selected_packet_size == kDefaultMaxPacketSize) {
+      connection->GattCharacteristicValueChanged(
+          adapter_.get(), rx_characteristic_.get(), kSmallConnectionResponse);
+    } else {
+      connection->GattCharacteristicValueChanged(
+          adapter_.get(), rx_characteristic_.get(), kLargeConnectionResponse);
+    }
 

[Kyle Horimoto, 2016/06/30 01:29:48]

Assert that the correct data packet size was set on the generator.

[jingxuy, 2016/06/30 21:59:25]

the test class has no access to generator reference as of now. If you wanted to
test this explicitly, there had to be a static variable in the generator that's
publicly accessible. But I think this is already tested  below as the
small/large packet size will return different messages. So if the packet size is
set incorrectly, it will fail some tests below.

[Kyle Horimoto, 2016/06/30 22:36:11]

Please test this explicitly. You should create an instance of the mock
generator/receiver classes and return these instances from the factories. That
way, the class can make calls on the generator/receiver and the test can make
calls to retrieve values for assertions from the generator/receiver.

[jingxuy, 2016/07/01 00:00:44]

Done.

-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::CONNECTED);
+    EXPECT_EQ(connection->sub_status(), SubStatus::CONNECTED);
     EXPECT_EQ(connection->status(), Connection::CONNECTED);
   }
 
   // Transitions |connection| to a DISCONNECTED state regardless of its initial
   // state.
-  void Disconnect(MockBluetoothLowEnergyConnection* connection) {
+  void Disconnect(TestBluetoothLowEnergyWeaveClientConnection* connection) {
     // A notify session was previously set.
     if (notify_session_alias_)
       EXPECT_CALL(*notify_session_alias_, Stop(_));
 
     connection->Disconnect();
 
-    EXPECT_EQ(connection->sub_status(),
-              BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+    EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
     EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
   }
 
-  void InitializeConnection(MockBluetoothLowEnergyConnection* connection) {
+  void InitializeConnection(
+      TestBluetoothLowEnergyWeaveClientConnection* connection,
+      uint32_t selected_packet_size) {
     ConnectGatt(connection);
     CharacteristicsFound(connection);
     NotifySessionStarted(connection);
-    ResponseSignalReceived(connection);
+    ConnectionResponseReceived(connection, selected_packet_size);
   }
 
   void RunWriteCharacteristicSuccessCallback() {
     EXPECT_FALSE(write_remote_characteristic_error_callback_.is_null());
     ASSERT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_success_callback_.Run();
   }
 
-  std::vector<uint8_t> CreateSendSignalWithSize(int message_size) {
-    std::vector<uint8_t> value = ToByteVector(static_cast<uint32_t>(
-        BluetoothLowEnergyConnection::ControlSignal::kSendSignal));
-    std::vector<uint8_t> size =
-        ToByteVector(static_cast<uint32_t>(message_size));
-    value.insert(value.end(), size.begin(), size.end());
-    return value;
-  }
-
-  std::vector<uint8_t> CreateFirstCharacteristicValue(
-      const std::string& message,
-      int size) {
-    std::vector<uint8_t> value(CreateSendSignalWithSize(size));
-    std::vector<uint8_t> bytes(message.begin(), message.end());
-    value.insert(value.end(), bytes.begin(), bytes.end());
-    return value;
-  }
-
-  std::vector<uint8_t> ToByteVector(uint32_t value) {
-    std::vector<uint8_t> bytes(4, 0);
-    bytes[0] = static_cast<uint8_t>(value);
-    bytes[1] = static_cast<uint8_t>(value >> 8);
-    bytes[2] = static_cast<uint8_t>(value >> 16);
-    bytes[3] = static_cast<uint8_t>(value >> 24);
-    return bytes;
-  }
-
  protected:
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   RemoteDevice remote_device_;
   device::BluetoothUUID service_uuid_;
-  device::BluetoothUUID to_peripheral_char_uuid_;
-  device::BluetoothUUID from_peripheral_char_uuid_;
+  device::BluetoothUUID tx_characteristic_uuid_;
+  device::BluetoothUUID rx_characteristic_uuid_;
   std::unique_ptr<device::MockBluetoothDevice> device_;
   std::unique_ptr<device::MockBluetoothGattService> service_;
-  std::unique_ptr<device::MockBluetoothGattCharacteristic> to_peripheral_char_;
-  std::unique_ptr<device::MockBluetoothGattCharacteristic>
-      from_peripheral_char_;
-  std::vector<uint8_t> last_value_written_on_to_peripheral_char_;
+  std::unique_ptr<device::MockBluetoothGattCharacteristic> tx_characteristic_;
+  std::unique_ptr<device::MockBluetoothGattCharacteristic> rx_characteristic_;
+  std::vector<uint8_t> last_value_written_on_tx_characteristic_;
   device::MockBluetoothGattNotifySession* notify_session_alias_;
   std::unique_ptr<MockBluetoothThrottler> bluetooth_throttler_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::MessageLoop message_loop_;
 
   // Callbacks
   device::BluetoothDevice::GattConnectionCallback
       create_gatt_connection_success_callback_;
   device::BluetoothDevice::ConnectErrorCallback
       create_gatt_connection_error_callback_;
 
   BluetoothLowEnergyCharacteristicsFinder::SuccessCallback
       characteristics_finder_success_callback_;
   BluetoothLowEnergyCharacteristicsFinder::ErrorCallback
       characteristics_finder_error_callback_;
 
   device::BluetoothRemoteGattCharacteristic::NotifySessionCallback
       notify_session_success_callback_;
   device::BluetoothRemoteGattCharacteristic::ErrorCallback
       notify_session_error_callback_;
 
   base::Closure write_remote_characteristic_success_callback_;
   device::BluetoothRemoteGattCharacteristic::ErrorCallback
       write_remote_characteristic_error_callback_;
+
+  MockBluetoothLowEnergyWeavePacketGeneratorFactory generator_factory_;
+  MockBluetoothLowEnergyWeavePacketReceiverFactory receiver_factory_;
 };
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       CreateAndDestroyWithouthConnectCallDoesntCrash) {
-  BluetoothLowEnergyConnection connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       CreateAndDestroyWithoutConnectCallDoesntCrash) {
+  BluetoothLowEnergyWeaveClientConnection connection(
       remote_device_, adapter_, service_uuid_, bluetooth_throttler_.get(),
       kMaxNumberOfTries);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Disconect_WithoutConnectDoesntCrash) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       DisconectWithoutConnectDoesntCrash) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest, Connect_Success) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectSuccess) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
-  ResponseSignalReceived(connection.get());
+  ConnectionResponseReceived(connection.get(), kDefaultMaxPacketSize);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Success_Disconnect) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectSuccessDisconnect) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingCharacteristicsState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingCharacteristicsState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingNotifySessionState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingNotifySessionState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Incomplete_Disconnect_FromWaitingResponseSignalState) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectIncompleteDisconnectFromWaitingConnectionResponseState) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   Disconnect(connection.get());
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_CharacteristicsNotFound) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsCharacteristicsNotFound) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
 
-  EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _)).Times(0);
+  EXPECT_CALL(*rx_characteristic_, StartNotifySession(_, _)).Times(0);
   EXPECT_FALSE(characteristics_finder_success_callback_.is_null());
   ASSERT_FALSE(characteristics_finder_error_callback_.is_null());
 
   characteristics_finder_error_callback_.Run(
-      {to_peripheral_char_uuid_, kToPeripheralCharID},
-      {from_peripheral_char_uuid_, kFromPeripheralCharID});
+      {tx_characteristic_uuid_, kTXCharacteristicID},
+      {rx_characteristic_uuid_, kRXCharacteristicID});
 
-  EXPECT_EQ(connection->sub_status(),
-            BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+  EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_NotifySessionError) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsNotifySessionError) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
 
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
-      .Times(0);
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _)).Times(0);
   EXPECT_FALSE(notify_session_success_callback_.is_null());
   ASSERT_FALSE(notify_session_error_callback_.is_null());
 
   notify_session_error_callback_.Run(
       device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
 
-  EXPECT_EQ(connection->sub_status(),
-            BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+  EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_Fails_ErrorSendingInviteToConnectSignal) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectFailsErrorSendingConnectionRequest) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
   ConnectGatt(connection.get());
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
 
   // |connection| will call WriteRemoteCharacteristics(_,_) to try to send the
   // message |kMaxNumberOfTries| times. There is alredy one EXPECTA_CALL for
   // WriteRemoteCharacteristic(_,_,_) in NotifySessionStated, that's why we use
   // |kMaxNumberOfTries-1| in the EXPECT_CALL statement.
   EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .Times(kMaxNumberOfTries - 1)
       .WillRepeatedly(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   for (int i = 0; i < kMaxNumberOfTries; i++) {
-    const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
-        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
-                                  kInviteToConnectSignal));
-    EXPECT_EQ(last_value_written_on_to_peripheral_char_,
-              kInviteToConnectSignal);
+    EXPECT_EQ(last_value_written_on_tx_characteristic_, kConnectionRequest);
     ASSERT_FALSE(write_remote_characteristic_error_callback_.is_null());
     EXPECT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_error_callback_.Run(
         device::BluetoothRemoteGattService::GATT_ERROR_UNKNOWN);
   }
 
-  EXPECT_EQ(connection->sub_status(),
-            BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
+  EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::DISCONNECTED);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Receive_MessageSmallerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ReceiveMessageSmallerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
 
   std::string received_bytes;
   EXPECT_CALL(*connection, OnBytesReceived(_))
       .WillOnce(SaveArg<0>(&received_bytes));
 
-  // Message (bytes) that is going to be received.
-  std::string message(100, 'A');
+  connection->GattCharacteristicValueChanged(
+      adapter_.get(), rx_characteristic_.get(), kSmallPackets[0]);
 
-  // Sending the |kSendSignal| + |message_size| + |message|.
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(),
-      CreateFirstCharacteristicValue(message, message.size()));
-
-  EXPECT_EQ(received_bytes, message);
+  EXPECT_EQ(received_bytes, kSmallMessage);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Receive_MessageLargerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ReceiveMessageLargerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+
+  const uint32_t selected_packet_size = 500;
+  InitializeConnection(connection.get(), selected_packet_size);
 
   std::string received_bytes;
-  int chunk_size = 500;
   EXPECT_CALL(*connection, OnBytesReceived(_))
       .WillOnce(SaveArg<0>(&received_bytes));
 
-  // Message (bytes) that is going to be received.
-  int message_size = 600;
-  std::string message(message_size, 'A');
+  std::vector<Packet> packets = kLargePackets;
 
-  // Sending the |kSendSignal| + |message_size| + |message| (truncated at
-  // |chunk_size|).
-  int first_write_payload_size =
-      chunk_size - CreateSendSignalWithSize(message_size).size();
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(),
-      CreateFirstCharacteristicValue(
-          message.substr(0, first_write_payload_size), message.size()));
-
-  // Sending the remaining bytes.
-  std::vector<uint8_t> value;
-  value.push_back(0);
-  value.insert(value.end(), message.begin() + first_write_payload_size,
-               message.end());
-  connection->GattCharacteristicValueChanged(
-      adapter_.get(), from_peripheral_char_.get(), value);
-
-  EXPECT_EQ(received_bytes, message);
+  for (auto packet : packets) {
+    connection->GattCharacteristicValueChanged(
+        adapter_.get(), rx_characteristic_.get(), packet);
+  }
+  EXPECT_EQ(received_bytes, kLargeMessage);
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       SendMessage_SmallerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       SendMessageSmallerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+  InitializeConnection(connection.get(), kDefaultMaxPacketSize);
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
-  // Message (bytes) that is going to be sent.
-  int message_size = 100;
-  std::string message(message_size, 'A');
-  message[0] = 'B';
-  connection->SendMessage(base::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::WrapUnique(new FakeWireMessage(kSmallMessage)));
 
-  // Expecting that |kSendSignal| + |message_size| + |message| was written.
-  EXPECT_EQ(last_value_written_on_to_peripheral_char_,
-            CreateFirstCharacteristicValue(message, message.size()));
+  EXPECT_EQ(last_value_written_on_tx_characteristic_, kSmallPackets[0]);
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
 
   RunWriteCharacteristicSuccessCallback();
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       SendMessage_LagerThanCharacteristicSize) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       SendMessageLargerThanCharacteristicSize) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
-  InitializeConnection(connection.get());
+
+  const uint32_t selected_packet_size = 500;
+  InitializeConnection(connection.get(), selected_packet_size);
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
-  // Message (bytes) that is going to be sent.
-  int message_size = 600;
-  std::string message(message_size, 'A');
-  message[0] = 'B';
-  connection->SendMessage(base::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::WrapUnique(new FakeWireMessage(kLargeMessage)));
 
-  // Expecting that |kSendSignal| + |message_size| was written in the first 8
-  // bytes.
-  std::vector<uint8_t> prefix(
-      last_value_written_on_to_peripheral_char_.begin(),
-      last_value_written_on_to_peripheral_char_.begin() + 8);
-  EXPECT_EQ(prefix, CreateSendSignalWithSize(message_size));
+  EXPECT_EQ(last_value_written_on_tx_characteristic_, kLargePackets[0]);
   std::vector<uint8_t> bytes_received(
-      last_value_written_on_to_peripheral_char_.begin() + 8,
-      last_value_written_on_to_peripheral_char_.end());
+      last_value_written_on_tx_characteristic_.begin() + 1,
+      last_value_written_on_tx_characteristic_.end());
 
-  // Expecting a second call of WriteRemoteCharacteristic, after success
-  // callback is called.
-  EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
+  EXPECT_CALL(*tx_characteristic_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
-          DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
+          DoAll(SaveArg<0>(&last_value_written_on_tx_characteristic_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   RunWriteCharacteristicSuccessCallback();
   bytes_received.insert(bytes_received.end(),
-                        last_value_written_on_to_peripheral_char_.begin() + 1,
-                        last_value_written_on_to_peripheral_char_.end());
+                        last_value_written_on_tx_characteristic_.begin() + 1,
+                        last_value_written_on_tx_characteristic_.end());
 
-  // Expecting that the message was written.
-  std::vector<uint8_t> expected_value(message.begin(), message.end());
-  EXPECT_EQ(expected_value.size(), bytes_received.size());
-  EXPECT_EQ(expected_value, bytes_received);
+  std::vector<uint8_t> expected(kLargeMessage.begin(), kLargeMessage.end());
+  EXPECT_EQ(expected, bytes_received);
 
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
   RunWriteCharacteristicSuccessCallback();
 }
 
-TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
-       Connect_AfterADelayWhenThrottled) {
-  std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
+TEST_F(ProximityAuthBluetoothLowEnergyWeaveClientConnectionTest,
+       ConnectAfterDelayWhenThrottled) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
       CreateConnection());
 
   EXPECT_CALL(*bluetooth_throttler_, GetDelay())
       .WillOnce(Return(base::TimeDelta(base::TimeDelta::FromSeconds(1))));
   EXPECT_CALL(*device_, CreateGattConnection(_, _))
       .WillOnce(DoAll(SaveArg<0>(&create_gatt_connection_success_callback_),
                       SaveArg<1>(&create_gatt_connection_error_callback_)));
 
   // No GATT connection should be created before the delay.
   connection->Connect();
-  EXPECT_EQ(connection->sub_status(),
-            BluetoothLowEnergyConnection::SubStatus::WAITING_GATT_CONNECTION);
+  EXPECT_EQ(connection->sub_status(), SubStatus::WAITING_GATT_CONNECTION);
   EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   EXPECT_TRUE(create_gatt_connection_error_callback_.is_null());
   EXPECT_TRUE(create_gatt_connection_success_callback_.is_null());
 
   // A GATT connection should be created after the delay.
   task_runner_->RunUntilIdle();
   EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
   ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
 
   // Preparing |connection| to run |create_gatt_connection_success_callback_|.
   EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
       .WillOnce(DoAll(
           SaveArg<0>(&characteristics_finder_success_callback_),
           SaveArg<1>(&characteristics_finder_error_callback_),
           Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
   create_gatt_connection_success_callback_.Run(
       base::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
           adapter_, kTestRemoteDeviceBluetoothAddress)));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
-  ResponseSignalReceived(connection.get());
+  ConnectionResponseReceived(connection.get(), kDefaultMaxPacketSize);
 }
 
+}  // namespace weave
+
 }  // namespace proximity_auth