[EasyUnlock] Add beacon_seeds to RemoteDevice.

components/cryptauth/remote_device_loader_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/cryptauth/remote_device_loader.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "components/cryptauth/fake_secure_message_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cryptauth {
 namespace {
 
 // Prefixes for RemoteDevice fields.
 const char kDeviceNamePrefix[] = "device";
 const char kPublicKeyPrefix[] = "pk";
 const char kBluetoothAddressPrefix[] = "11:22:33:44:55:0";
 
 // The id of the user who the remote devices belong to.
 const char kUserId[] = "example@gmail.com";
 
 // The public key of the user's local device.
 const char kUserPublicKey[] = "User public key";
 
+// BeaconSeed values.
+const int64_t kBeaconSeedStartTimeMs = 1000;
+const int64_t kBeaconSeedEndTimeMs = 2000;
+const char kBeaconSeedData[] = "Beacon Seed Data";
+
 // Creates and returns an ExternalDeviceInfo proto with the fields appended with
 // |suffix|.
 cryptauth::ExternalDeviceInfo CreateDeviceInfo(const std::string& suffix) {
   cryptauth::ExternalDeviceInfo device_info;
   device_info.set_friendly_device_name(std::string(kDeviceNamePrefix) + suffix);
   device_info.set_public_key(std::string(kPublicKeyPrefix) + suffix);
   device_info.set_bluetooth_address(std::string(kBluetoothAddressPrefix) +
                                    suffix);
+  device_info.add_beacon_seeds();
+  BeaconSeed* beacon_seed = device_info.mutable_beacon_seeds(0);
+  beacon_seed->set_start_time_millis(kBeaconSeedStartTimeMs);
+  beacon_seed->set_end_time_millis(kBeaconSeedEndTimeMs);
+  beacon_seed->set_data(kBeaconSeedData);
   return device_info;
 }
 
 }  // namespace
 
 class CryptAuthRemoteDeviceLoaderTest : public testing::Test {
  public:
   CryptAuthRemoteDeviceLoaderTest()
       : secure_message_delegate_(new cryptauth::FakeSecureMessageDelegate()),
         user_private_key_(secure_message_delegate_->GetPrivateKeyForPublicKey(
@@ skipping 25 matching lines @@
 };
 
 TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadZeroDevices) {
   std::vector<cryptauth::ExternalDeviceInfo> device_infos;
   RemoteDeviceLoader loader(device_infos, user_private_key_, kUserId,
                             std::move(secure_message_delegate_));
 
   std::vector<cryptauth::RemoteDevice> result;
   EXPECT_CALL(*this, LoadCompleted());
   loader.Load(
-      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
-                 base::Unretained(this)));
+      false, base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                        base::Unretained(this)));
 
   EXPECT_EQ(0u, remote_devices_.size());
 }
 
+TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadOneDeviceWithBeaconSeeds) {
+  std::vector<cryptauth::ExternalDeviceInfo> device_infos(
+      1, CreateDeviceInfo("0"));
+  RemoteDeviceLoader loader(device_infos, user_private_key_, kUserId,
+                            std::move(secure_message_delegate_));
+
+  std::vector<cryptauth::RemoteDevice> result;
+  EXPECT_CALL(*this, LoadCompleted());
+  loader.Load(
+      true, base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                       base::Unretained(this)));
+
+  EXPECT_EQ(1u, remote_devices_.size());
+  EXPECT_FALSE(remote_devices_[0].persistent_symmetric_key.empty());
+  EXPECT_EQ(device_infos[0].friendly_device_name(), remote_devices_[0].name);
+  EXPECT_EQ(device_infos[0].public_key(), remote_devices_[0].public_key);
+  EXPECT_TRUE(remote_devices_[0].are_beacon_seeds_loaded);
+  ASSERT_EQ(1u, remote_devices_[0].beacon_seeds.size());
+
+  const BeaconSeed& beacon_seed = remote_devices_[0].beacon_seeds[0];
+  EXPECT_EQ(kBeaconSeedData, beacon_seed.data());
+  EXPECT_EQ(kBeaconSeedStartTimeMs, beacon_seed.start_time_millis());
+  EXPECT_EQ(kBeaconSeedEndTimeMs, beacon_seed.end_time_millis());
+}
+
+TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadDevicesWithAndWithoutBeaconSeeds) {
+  std::vector<cryptauth::ExternalDeviceInfo> device_infos(
+      1, CreateDeviceInfo("0"));
+
+  RemoteDeviceLoader loader1(device_infos, user_private_key_, kUserId,
+                             base::MakeUnique<FakeSecureMessageDelegate>());
+  EXPECT_CALL(*this, LoadCompleted());
+  loader1.Load(
+      false /* should_load_beacon_seeds */,
+      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                 base::Unretained(this)));
+  RemoteDevice remote_device_without_beacon_seed = remote_devices_[0];
+
+  RemoteDeviceLoader loader2(device_infos, user_private_key_, kUserId,
+                             base::MakeUnique<FakeSecureMessageDelegate>());
+  EXPECT_CALL(*this, LoadCompleted());
+  loader2.Load(
+      true /* should_load_beacon_seeds */,
+      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                 base::Unretained(this)));
+  RemoteDevice remote_device_with_beacon_seed = remote_devices_[0];
+
+  EXPECT_EQ(remote_device_without_beacon_seed,
+            remote_device_without_beacon_seed);
+  EXPECT_EQ(remote_device_with_beacon_seed, remote_device_with_beacon_seed);
+  EXPECT_FALSE(remote_device_with_beacon_seed ==
+               remote_device_without_beacon_seed);
+}
+
 TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadOneDeviceWithAddress) {
   std::vector<cryptauth::ExternalDeviceInfo> device_infos(1,
                                                          CreateDeviceInfo("0"));
   RemoteDeviceLoader loader(device_infos, user_private_key_, kUserId,
                             std::move(secure_message_delegate_));
 
   std::vector<cryptauth::RemoteDevice> result;
   EXPECT_CALL(*this, LoadCompleted());
   loader.Load(
-      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
-                 base::Unretained(this)));
+      false, base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                        base::Unretained(this)));
 
   EXPECT_EQ(1u, remote_devices_.size());
   EXPECT_FALSE(remote_devices_[0].persistent_symmetric_key.empty());
   EXPECT_EQ(device_infos[0].friendly_device_name(), remote_devices_[0].name);
   EXPECT_EQ(device_infos[0].public_key(), remote_devices_[0].public_key);
   EXPECT_EQ(device_infos[0].bluetooth_address(),
             remote_devices_[0].bluetooth_address);
+  EXPECT_EQ(0u, remote_devices_[0].beacon_seeds.size());
 }
 
 TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadOneDeviceWithoutAddress) {
   std::vector<cryptauth::ExternalDeviceInfo> device_infos(1,
                                                          CreateDeviceInfo("0"));
   device_infos[0].set_bluetooth_address(std::string());
   RemoteDeviceLoader loader(device_infos, user_private_key_, kUserId,
                             std::move(secure_message_delegate_));
 
   std::vector<cryptauth::RemoteDevice> result;
   EXPECT_CALL(*this, LoadCompleted());
   loader.Load(
-      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
-                 base::Unretained(this)));
+      false, base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                        base::Unretained(this)));
 
   EXPECT_EQ(1u, remote_devices_.size());
   EXPECT_FALSE(remote_devices_[0].persistent_symmetric_key.empty());
   EXPECT_EQ(device_infos[0].friendly_device_name(), remote_devices_[0].name);
   EXPECT_EQ(device_infos[0].public_key(), remote_devices_[0].public_key);
   EXPECT_EQ("", remote_devices_[0].bluetooth_address);
 }
 
 TEST_F(CryptAuthRemoteDeviceLoaderTest, LoadThreeRemoteDevices) {
   std::vector<cryptauth::ExternalDeviceInfo> device_infos;
   device_infos.push_back(CreateDeviceInfo("0"));
   device_infos.push_back(CreateDeviceInfo("1"));
   device_infos.push_back(CreateDeviceInfo("2"));
 
   // Devices 0 and 1 do not have a Bluetooth address, but device 2 does.
   device_infos[0].set_bluetooth_address(std::string());
   device_infos[1].set_bluetooth_address(std::string());
 
   RemoteDeviceLoader loader(device_infos, user_private_key_, kUserId,
                             std::move(secure_message_delegate_));
 
   EXPECT_CALL(*this, LoadCompleted());
   loader.Load(
-      base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
-                 base::Unretained(this)));
+      false, base::Bind(&CryptAuthRemoteDeviceLoaderTest::OnRemoteDevicesLoaded,
+                        base::Unretained(this)));
 
   EXPECT_EQ(3u, remote_devices_.size());
   for (size_t i = 0; i < 3; ++i) {
     EXPECT_FALSE(remote_devices_[i].persistent_symmetric_key.empty());
     EXPECT_EQ(device_infos[i].friendly_device_name(), remote_devices_[i].name);
     EXPECT_EQ(device_infos[i].public_key(), remote_devices_[i].public_key);
     EXPECT_EQ(device_infos[i].bluetooth_address(),
               remote_devices_[i].bluetooth_address);
   }
 }
 
 }  // namespace cryptauth