| // Copyright 2018 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 "chromeos/services/multidevice_setup/account_status_change_delegate_notifier_impl.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/test/scoped_task_environment.h" |
| #include "base/test/simple_test_clock.h" |
| #include "base/time/time.h" |
| #include "chromeos/components/multidevice/remote_device_ref.h" |
| #include "chromeos/components/multidevice/remote_device_test_util.h" |
| #include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h" |
| #include "chromeos/services/multidevice_setup/fake_account_status_change_delegate.h" |
| #include "chromeos/services/multidevice_setup/fake_host_device_timestamp_manager.h" |
| #include "chromeos/services/multidevice_setup/fake_host_status_provider.h" |
| #include "chromeos/services/multidevice_setup/public/cpp/oobe_completion_tracker.h" |
| #include "chromeos/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h" |
| #include "components/sync_preferences/testing_pref_service_syncable.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace chromeos { |
| |
| namespace multidevice_setup { |
| |
| namespace { |
| |
| const int64_t kTestTimeMillis = 1500000000000; |
| const char kFakePhoneKey[] = "fake-phone-key"; |
| const char kFakePhoneName[] = "Phony Phone"; |
| const char kFakePhoneKeyA[] = "fake-phone-key-A"; |
| const char kFakePhoneNameA[] = "Phony Phone A"; |
| const char kFakePhoneKeyB[] = "fake-phone-key-B"; |
| const char kFakePhoneNameB[] = "Phony Phone B"; |
| |
| const multidevice::RemoteDeviceRef kFakePhone = |
| multidevice::RemoteDeviceRefBuilder() |
| .SetPublicKey(kFakePhoneKey) |
| .SetName(kFakePhoneName) |
| .Build(); |
| |
| // Alternate hosts for multi host tests |
| const multidevice::RemoteDeviceRef kFakePhoneA = |
| multidevice::RemoteDeviceRefBuilder() |
| .SetPublicKey("fake-phone-key-A") |
| .SetName("Phony Phone A") |
| .Build(); |
| const multidevice::RemoteDeviceRef kFakePhoneB = |
| multidevice::RemoteDeviceRefBuilder() |
| .SetPublicKey("fake-phone-key-B") |
| .SetName("Phony Phone B") |
| .Build(); |
| |
| } // namespace |
| |
| class MultiDeviceSetupAccountStatusChangeDelegateNotifierTest |
| : public testing::Test { |
| protected: |
| MultiDeviceSetupAccountStatusChangeDelegateNotifierTest() = default; |
| |
| ~MultiDeviceSetupAccountStatusChangeDelegateNotifierTest() override = default; |
| |
| void SetUp() override { |
| test_pref_service_ = |
| std::make_unique<sync_preferences::TestingPrefServiceSyncable>(); |
| AccountStatusChangeDelegateNotifierImpl::RegisterPrefs( |
| test_pref_service_->registry()); |
| |
| fake_delegate_ = std::make_unique<FakeAccountStatusChangeDelegate>(); |
| fake_host_status_provider_ = std::make_unique<FakeHostStatusProvider>(); |
| test_clock_ = std::make_unique<base::SimpleTestClock>(); |
| fake_host_device_timestamp_manager_ = |
| std::make_unique<FakeHostDeviceTimestampManager>(); |
| fake_oobe_completion_tracker_ = std::make_unique<OobeCompletionTracker>(); |
| test_clock_->SetNow(base::Time::FromJavaTime(kTestTimeMillis)); |
| } |
| |
| void BuildAccountStatusChangeDelegateNotifier() { |
| delegate_notifier_ = |
| AccountStatusChangeDelegateNotifierImpl::Factory::Get()->BuildInstance( |
| fake_host_status_provider_.get(), test_pref_service_.get(), |
| fake_host_device_timestamp_manager_.get(), |
| fake_oobe_completion_tracker_.get(), test_clock_.get()); |
| } |
| |
| multidevice::RemoteDeviceRef BuildFakePhone(std::string public_key, |
| std::string name) { |
| return multidevice::RemoteDeviceRefBuilder() |
| .SetPublicKey(public_key) |
| .SetName(name) |
| .Build(); |
| } |
| |
| void SetHostWithStatus( |
| mojom::HostStatus host_status, |
| const base::Optional<multidevice::RemoteDeviceRef>& host_device) { |
| fake_host_status_provider_->SetHostWithStatus(host_status, host_device); |
| delegate_notifier_->FlushForTesting(); |
| } |
| |
| // Simulates finding a potential host, going through setup flow with it, and |
| // verifying it. |
| void SetUpHost(const multidevice::RemoteDeviceRef& host_device) { |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| fake_host_device_timestamp_manager_->set_was_host_set_from_this_chromebook( |
| true); |
| SetHostWithStatus( |
| mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation, |
| host_device); |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, host_device); |
| } |
| |
| // Simulates forgetting a set host. |
| void ForgetHost() { |
| fake_host_device_timestamp_manager_->set_was_host_set_from_this_chromebook( |
| false); |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| } |
| |
| void SetNewUserPotentialHostExistsTimestamp(int64_t timestamp) { |
| test_pref_service_->SetInt64(AccountStatusChangeDelegateNotifierImpl:: |
| kNewUserPotentialHostExistsPrefName, |
| timestamp); |
| } |
| |
| void SetExistingUserChromebookAddedTimestamp(int64_t timestamp) { |
| test_pref_service_->SetInt64(AccountStatusChangeDelegateNotifierImpl:: |
| kExistingUserChromebookAddedPrefName, |
| timestamp); |
| } |
| |
| void SetHostFromPreviousSession(std::string old_host_key) { |
| std::string old_host_device_id = |
| multidevice::RemoteDevice::GenerateDeviceId(old_host_key); |
| test_pref_service_->SetString( |
| AccountStatusChangeDelegateNotifierImpl:: |
| kVerifiedHostDeviceIdFromMostRecentHostStatusUpdatePrefName, |
| old_host_device_id); |
| } |
| |
| void SetAccountStatusChangeDelegatePtr() { |
| delegate_notifier_->SetAccountStatusChangeDelegatePtr( |
| fake_delegate_->GenerateInterfacePtr()); |
| delegate_notifier_->FlushForTesting(); |
| } |
| |
| // Simulates completing setup flow in OOBE. |
| void CompleteOobeSetupFlow() { |
| fake_host_status_provider_->SetHostWithStatus( |
| mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| fake_oobe_completion_tracker_->MarkOobeShown(); |
| if (fake_delegate_) |
| delegate_notifier_->FlushForTesting(); |
| } |
| |
| int64_t GetNewUserPotentialHostExistsTimestamp() { |
| return test_pref_service_->GetInt64( |
| AccountStatusChangeDelegateNotifierImpl:: |
| kNewUserPotentialHostExistsPrefName); |
| } |
| |
| int64_t GetExistingUserChromebookAddedTimestamp() { |
| return test_pref_service_->GetInt64( |
| AccountStatusChangeDelegateNotifierImpl:: |
| kExistingUserChromebookAddedPrefName); |
| } |
| |
| int64_t GetOobeSetupFlowTimestamp() { |
| return test_pref_service_->GetInt64( |
| AccountStatusChangeDelegateNotifierImpl:: |
| kOobeSetupFlowTimestampPrefName); |
| } |
| |
| std::string GetMostRecentVerifiedHostDeviceIdPref() { |
| return test_pref_service_->GetString( |
| AccountStatusChangeDelegateNotifierImpl:: |
| kVerifiedHostDeviceIdFromMostRecentHostStatusUpdatePrefName); |
| } |
| |
| FakeAccountStatusChangeDelegate* fake_delegate() { |
| return fake_delegate_.get(); |
| } |
| |
| private: |
| base::test::ScopedTaskEnvironment scoped_task_environment_; |
| |
| std::unique_ptr<FakeAccountStatusChangeDelegate> fake_delegate_; |
| std::unique_ptr<FakeHostStatusProvider> fake_host_status_provider_; |
| std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> |
| test_pref_service_; |
| std::unique_ptr<FakeHostDeviceTimestampManager> |
| fake_host_device_timestamp_manager_; |
| std::unique_ptr<OobeCompletionTracker> fake_oobe_completion_tracker_; |
| std::unique_ptr<base::SimpleTestClock> test_clock_; |
| |
| std::unique_ptr<AccountStatusChangeDelegateNotifier> delegate_notifier_; |
| |
| DISALLOW_COPY_AND_ASSIGN( |
| MultiDeviceSetupAccountStatusChangeDelegateNotifierTest); |
| }; |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| SetObserverWithPotentialHost) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(kTestTimeMillis, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| PotentialHostAddedLater) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| SetHostWithStatus(mojom::HostStatus::kNoEligibleHosts, |
| base::nullopt /* host_device */); |
| |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(kTestTimeMillis, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| OnlyPotentialHostCausesNewUserEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| SetHostWithStatus(mojom::HostStatus::kNoEligibleHosts, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| |
| SetHostWithStatus( |
| mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NoNewUserEventWithoutObserverSet) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| // All conditions for new user event are satisfied except for setting a |
| // delegate. |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NewUserFlowBlockedByOldNewUserTimestamp) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| int64_t earlier_test_time_millis = kTestTimeMillis / 2; |
| SetNewUserPotentialHostExistsTimestamp(earlier_test_time_millis); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| // Timestamp was not overwritten by clock. |
| EXPECT_EQ(earlier_test_time_millis, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NewUserFlowBlockedByOldChromebookAddedTimestamp) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| int64_t earlier_test_time_millis = kTestTimeMillis / 2; |
| SetExistingUserChromebookAddedTimestamp(earlier_test_time_millis); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| // Timestamp was not overwritten by clock. |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| LosingPotentialHostTriggersNoLongerNewUserEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| |
| // All potential hosts are lost from the account. |
| SetHostWithStatus(mojom::HostStatus::kNoEligibleHosts, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(1u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| SettingHostTriggersNoLongerNewUserEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| |
| // A potential host was set. |
| SetHostWithStatus( |
| mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(1u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| CompletingOobeSetupFlowBlocksNewUserEventIfNoDelegateIsSet) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| |
| // Complete OOBE MultiDevice setup flow before delegate is set. |
| EXPECT_EQ(0u, GetOobeSetupFlowTimestamp()); |
| CompleteOobeSetupFlow(); |
| EXPECT_EQ(kTestTimeMillis, GetOobeSetupFlowTimestamp()); |
| |
| // Set delegate, which triggers event check. |
| SetAccountStatusChangeDelegatePtr(); |
| |
| EXPECT_EQ(0u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(0u, GetNewUserPotentialHostExistsTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| CompletingOobeSetupFlowWithDelegateSetTriggersNoLongerNewUserEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| |
| // Complete OOBE MultiDevice setup flow before delegate is set. |
| EXPECT_EQ(0u, GetOobeSetupFlowTimestamp()); |
| CompleteOobeSetupFlow(); |
| EXPECT_EQ(kTestTimeMillis, GetOobeSetupFlowTimestamp()); |
| |
| EXPECT_EQ(1u, fake_delegate()->num_new_user_potential_host_events_handled()); |
| EXPECT_EQ(1u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NoLongerNewUserEventBlockedByOldChromebookAddedTimestamp) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| // Record earlier Chromebook added event. |
| int64_t earlier_test_time_millis = kTestTimeMillis / 2; |
| SetExistingUserChromebookAddedTimestamp(earlier_test_time_millis); |
| |
| // A potential host was found. |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| |
| // A potential host was set. Note that this would trigger a NoLongerNewUser |
| // event in the absence of the Chromebook added timestamp. |
| SetHostWithStatus( |
| mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, fake_delegate()->num_no_longer_new_user_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NotifiesObserverForHostSwitchEvents) { |
| const multidevice::RemoteDeviceRef fakePhone = |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Check the delegate initializes to 0. |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| // Host was set but has never been switched. |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Switch to new verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA)); |
| EXPECT_EQ(1u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Switch to a different new verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyB, kFakePhoneNameB)); |
| EXPECT_EQ(2u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Switch back to initial host (verified). |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| EXPECT_EQ(3u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| SettingSameHostTriggersNoHostSwitchedEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| // Set to host with identical information. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| ChangingHostDevicesTriggersHostSwitchEventWhenHostNameIsUnchanged) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| // Set to verified host with same name but different key. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneName)); |
| EXPECT_EQ(1u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| VerifyingSetHostTriggersNoHostSwtichEvent) { |
| const multidevice::RemoteDeviceRef fakePhone = |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Set initial host but do not verify. |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, fakePhone); |
| // Verify host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| OnlyVerifiedHostCausesHostSwitchedEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Set a new host without verifying. |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Set a different new host without confirming with backend so host is |
| // unverified. |
| SetHostWithStatus( |
| mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation, |
| BuildFakePhone(kFakePhoneKeyB, kFakePhoneNameB)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| ForgettingAndThenSwitchingHostsDoesNotTriggerHostSwitchedEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| ForgetHost(); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| |
| // Set a new verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| HostSwitchedBetweenSessions) { |
| // Host set in some previous session. |
| SetHostFromPreviousSession( |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA).GetDeviceId()); |
| BuildAccountStatusChangeDelegateNotifier(); |
| // Host switched and verified between sessions. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| SetAccountStatusChangeDelegatePtr(); |
| EXPECT_EQ(1u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NoHostSwitchedEventWithoutExistingHost) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| SetUpHost(BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NoHostSwitchedEventWithoutObserverSet) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| // All conditions for host switched event are satisfied except for setting a |
| // delegate. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA)); |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NotifiesObserverForChromebookAddedEvents) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Check the delegate initializes to 0. |
| EXPECT_EQ( |
| 0u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| |
| // Host is set and verified from another Chromebook while this one is logged |
| // in. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| OnlyVerifiedHostCausesChromebookAddedEvent) { |
| const multidevice::RemoteDeviceRef fakePhone = |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Start with potential hosts but none set. |
| SetHostWithStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet, |
| base::nullopt /* host_device */); |
| |
| // Set a host without verifying. |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, fakePhone); |
| EXPECT_EQ( |
| 0u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| |
| // Verify the new host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| ReplacingUnverifiedHostAWithVerifiedHostBCausesChromebookAddedEvent) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Start with potential hosts but none set. |
| // Set initial host but do not verify. |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA)); |
| |
| // Replace unverified Phone A with verified Phone B. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKeyB, kFakePhoneNameB)); |
| // This causes a 'Chromebook added' event. |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| // It does not cause a 'host switched' event. |
| EXPECT_EQ(0u, |
| fake_delegate()->num_existing_user_host_switched_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| ChromebookAddedBetweenSessionsTriggersEvents) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| // Host is set and verified before this Chromebook is logged in. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| |
| SetAccountStatusChangeDelegatePtr(); |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| ChromebookAddedEventBlockedIfHostWasSetFromThisChromebook) { |
| const multidevice::RemoteDeviceRef fakePhone = |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| SetUpHost(fakePhone); |
| // The host was set on this Chromebook so it should not trigger the Chromebook |
| // added event |
| EXPECT_EQ( |
| 0u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| |
| ForgetHost(); |
| // Set verified host on another Chromebook. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| OldTimestampInPreferencesDoesNotPreventChromebookAddedEvent) { |
| int64_t earlier_test_time_millis = kTestTimeMillis / 2; |
| SetExistingUserChromebookAddedTimestamp(earlier_test_time_millis); |
| // Check timestamp was written. |
| EXPECT_EQ(earlier_test_time_millis, |
| GetExistingUserChromebookAddedTimestamp()); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ( |
| 1u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| // Timestamp was overwritten by clock. |
| EXPECT_EQ(kTestTimeMillis, GetExistingUserChromebookAddedTimestamp()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| NoChromebookAddedEventWithoutObserverSet) { |
| BuildAccountStatusChangeDelegateNotifier(); |
| // Triggers event check. Note that all conditions for Chromebook added event |
| // are satisfied except for setting a delegate. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName)); |
| EXPECT_EQ( |
| 0u, fake_delegate()->num_existing_user_chromebook_added_events_handled()); |
| } |
| |
| TEST_F(MultiDeviceSetupAccountStatusChangeDelegateNotifierTest, |
| VerifiedHostIdStaysUpToDateInPrefs) { |
| const multidevice::RemoteDeviceRef fakePhone = |
| BuildFakePhone(kFakePhoneKey, kFakePhoneName); |
| const multidevice::RemoteDeviceRef fakePhoneA = |
| BuildFakePhone(kFakePhoneKeyA, kFakePhoneNameA); |
| |
| BuildAccountStatusChangeDelegateNotifier(); |
| SetAccountStatusChangeDelegatePtr(); |
| // Check the delegate initializes to empty. |
| EXPECT_EQ(GetMostRecentVerifiedHostDeviceIdPref(), ""); |
| |
| // Set initially verified host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhone); |
| EXPECT_EQ(GetMostRecentVerifiedHostDeviceIdPref(), fakePhone.GetDeviceId()); |
| |
| // Switch to an unverified host. |
| SetHostWithStatus(mojom::HostStatus::kHostSetButNotYetVerified, fakePhoneA); |
| // The host is set but not verified so the pref should be set to empty. |
| EXPECT_EQ(GetMostRecentVerifiedHostDeviceIdPref(), ""); |
| |
| // Verify the new host. |
| SetHostWithStatus(mojom::HostStatus::kHostVerified, fakePhoneA); |
| EXPECT_EQ(GetMostRecentVerifiedHostDeviceIdPref(), fakePhoneA.GetDeviceId()); |
| |
| ForgetHost(); |
| EXPECT_EQ(GetMostRecentVerifiedHostDeviceIdPref(), ""); |
| } |
| |
| } // namespace multidevice_setup |
| |
| } // namespace chromeos |