| // 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_beacon_seed_fetcher.h" |
| |
| #include "base/macros.h" |
| #include "base/memory/ptr_util.h" |
| #include "components/cryptauth/cryptauth_client.h" |
| #include "components/cryptauth/cryptauth_device_manager.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using testing::StrictMock; |
| using testing::Return; |
| |
| namespace cryptauth { |
| |
| namespace { |
| |
| const std::string fake_beacon_seed1_data = "fakeBeaconSeed1Data"; |
| const int64_t fake_beacon_seed1_start_ms = 1000L; |
| const int64_t fake_beacon_seed1_end_ms = 2000L; |
| |
| const std::string fake_beacon_seed2_data = "fakeBeaconSeed2Data"; |
| const int64_t fake_beacon_seed2_start_ms = 2000L; |
| const int64_t fake_beacon_seed2_end_ms = 3000L; |
| |
| const std::string fake_beacon_seed3_data = "fakeBeaconSeed3Data"; |
| const int64_t fake_beacon_seed3_start_ms = 1000L; |
| const int64_t fake_beacon_seed3_end_ms = 2000L; |
| |
| const std::string fake_beacon_seed4_data = "fakeBeaconSeed4Data"; |
| const int64_t fake_beacon_seed4_start_ms = 2000L; |
| const int64_t fake_beacon_seed4_end_ms = 3000L; |
| |
| const std::string public_key1 = "publicKey1"; |
| const std::string public_key2 = "publicKey2"; |
| |
| class MockDeviceManager : public CryptAuthDeviceManager { |
| public: |
| MockDeviceManager() {} |
| ~MockDeviceManager() override {} |
| |
| MOCK_CONST_METHOD0(GetSyncedDevices, std::vector<ExternalDeviceInfo>()); |
| }; |
| |
| RemoteDevice CreateRemoteDevice(const std::string& public_key) { |
| RemoteDevice remote_device; |
| remote_device.public_key = public_key; |
| return remote_device; |
| } |
| |
| ExternalDeviceInfo CreateFakeInfo1() { |
| BeaconSeed seed1; |
| seed1.set_data(fake_beacon_seed1_data); |
| seed1.set_start_time_millis(fake_beacon_seed1_start_ms); |
| seed1.set_end_time_millis(fake_beacon_seed1_end_ms); |
| |
| BeaconSeed seed2; |
| seed2.set_data(fake_beacon_seed2_data); |
| seed2.set_start_time_millis(fake_beacon_seed2_start_ms); |
| seed2.set_end_time_millis(fake_beacon_seed2_end_ms); |
| |
| ExternalDeviceInfo info1; |
| info1.set_public_key(public_key1); |
| info1.add_beacon_seeds()->CopyFrom(seed1); |
| info1.add_beacon_seeds()->CopyFrom(seed2); |
| return info1; |
| } |
| |
| ExternalDeviceInfo CreateFakeInfo2() { |
| BeaconSeed seed3; |
| seed3.set_data(fake_beacon_seed3_data); |
| seed3.set_start_time_millis(fake_beacon_seed3_start_ms); |
| seed3.set_end_time_millis(fake_beacon_seed3_end_ms); |
| |
| BeaconSeed seed4; |
| seed4.set_data(fake_beacon_seed4_data); |
| seed4.set_start_time_millis(fake_beacon_seed4_start_ms); |
| seed4.set_end_time_millis(fake_beacon_seed4_end_ms); |
| |
| ExternalDeviceInfo info2; |
| info2.set_public_key(public_key2); |
| info2.add_beacon_seeds()->CopyFrom(seed3); |
| info2.add_beacon_seeds()->CopyFrom(seed4); |
| return info2; |
| } |
| |
| } // namespace |
| |
| class CryptAuthRemoteBeaconSeedFetcherTest : public testing::Test { |
| protected: |
| CryptAuthRemoteBeaconSeedFetcherTest() |
| : fake_info1_(CreateFakeInfo1()), fake_info2_(CreateFakeInfo2()) {} |
| |
| void SetUp() override { |
| mock_device_manager_ = base::MakeUnique<MockDeviceManager>(); |
| fetcher_ = base::MakeUnique<StrictMock<RemoteBeaconSeedFetcher>>( |
| mock_device_manager_.get()); |
| } |
| |
| std::unique_ptr<RemoteBeaconSeedFetcher> fetcher_; |
| std::unique_ptr<MockDeviceManager> mock_device_manager_; |
| |
| const ExternalDeviceInfo fake_info1_; |
| const ExternalDeviceInfo fake_info2_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(CryptAuthRemoteBeaconSeedFetcherTest); |
| }; |
| |
| TEST_F(CryptAuthRemoteBeaconSeedFetcherTest, TestRemoteDeviceWithNoPublicKey) { |
| RemoteDevice device = CreateRemoteDevice(""); |
| |
| std::vector<BeaconSeed> seeds; |
| EXPECT_FALSE(fetcher_->FetchSeedsForDevice(device, &seeds)); |
| } |
| |
| TEST_F(CryptAuthRemoteBeaconSeedFetcherTest, TestNoSyncedDevices) { |
| RemoteDevice device = CreateRemoteDevice(public_key1); |
| |
| EXPECT_CALL(*mock_device_manager_, GetSyncedDevices()) |
| .WillOnce(Return(std::vector<ExternalDeviceInfo>())); |
| |
| std::vector<BeaconSeed> seeds; |
| EXPECT_FALSE(fetcher_->FetchSeedsForDevice(device, &seeds)); |
| } |
| |
| TEST_F(CryptAuthRemoteBeaconSeedFetcherTest, TestDeviceHasDifferentPublicKey) { |
| // A public key which is different from the public keys of all of the synced |
| // devices. |
| RemoteDevice device = CreateRemoteDevice("differentPublicKey"); |
| |
| std::vector<ExternalDeviceInfo> device_infos = {fake_info1_, fake_info2_}; |
| EXPECT_CALL(*mock_device_manager_, GetSyncedDevices()) |
| .WillOnce(Return(device_infos)); |
| |
| std::vector<BeaconSeed> seeds; |
| EXPECT_FALSE(fetcher_->FetchSeedsForDevice(device, &seeds)); |
| } |
| |
| TEST_F(CryptAuthRemoteBeaconSeedFetcherTest, TestSuccess) { |
| RemoteDevice device1 = CreateRemoteDevice(public_key1); |
| RemoteDevice device2 = CreateRemoteDevice(public_key2); |
| |
| std::vector<ExternalDeviceInfo> device_infos = {fake_info1_, fake_info2_}; |
| EXPECT_CALL(*mock_device_manager_, GetSyncedDevices()) |
| .Times(2) |
| .WillRepeatedly(Return(device_infos)); |
| |
| std::vector<BeaconSeed> seeds1; |
| ASSERT_TRUE(fetcher_->FetchSeedsForDevice(device1, &seeds1)); |
| ASSERT_EQ(static_cast<size_t>(2), seeds1.size()); |
| EXPECT_EQ(fake_beacon_seed1_data, seeds1[0].data()); |
| EXPECT_EQ(fake_beacon_seed1_start_ms, seeds1[0].start_time_millis()); |
| EXPECT_EQ(fake_beacon_seed1_end_ms, seeds1[0].end_time_millis()); |
| EXPECT_EQ(fake_beacon_seed2_data, seeds1[1].data()); |
| EXPECT_EQ(fake_beacon_seed2_start_ms, seeds1[1].start_time_millis()); |
| EXPECT_EQ(fake_beacon_seed2_end_ms, seeds1[1].end_time_millis()); |
| |
| std::vector<BeaconSeed> seeds2; |
| ASSERT_TRUE(fetcher_->FetchSeedsForDevice(device2, &seeds2)); |
| ASSERT_EQ(static_cast<size_t>(2), seeds2.size()); |
| EXPECT_EQ(fake_beacon_seed3_data, seeds2[0].data()); |
| EXPECT_EQ(fake_beacon_seed3_start_ms, seeds2[0].start_time_millis()); |
| EXPECT_EQ(fake_beacon_seed3_end_ms, seeds2[0].end_time_millis()); |
| EXPECT_EQ(fake_beacon_seed4_data, seeds2[1].data()); |
| EXPECT_EQ(fake_beacon_seed4_start_ms, seeds2[1].start_time_millis()); |
| EXPECT_EQ(fake_beacon_seed4_end_ms, seeds2[1].end_time_millis()); |
| } |
| |
| } // namespace cryptauth |