[EasyUnlock] Force user to enter their password after 20 hours.

components/proximity_auth/proximity_auth_system_unittest.cc

 // Copyright 2014 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/proximity_auth_system.h"
 
+#include "base/test/simple_test_clock.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/proximity_auth/fake_lock_handler.h"
 #include "components/proximity_auth/fake_remote_device_life_cycle.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/mock_proximity_auth_client.h"
+#include "components/proximity_auth/proximity_auth_pref_manager.h"
 #include "components/proximity_auth/unlock_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using cryptauth::RemoteDevice;
 using cryptauth::RemoteDeviceList;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::InSequence;
 using testing::NiceMock;
 using testing::NotNull;
 using testing::Return;
 using testing::SaveArg;
 using testing::_;
 
 namespace proximity_auth {
 
 namespace {
 
 const char kUser1[] = "user1";
 const char kUser2[] = "user2";
 
+const int64_t kLastPasswordEntryTimestampMs = 123456L;
+const int64_t kTimestampBeforeReauthMs = 123457L;
+const int64_t kTimestampAfterReauthMs = 123457890123L;
+
 void CompareRemoteDeviceLists(const RemoteDeviceList& list1,
                               const RemoteDeviceList& list2) {
   ASSERT_EQ(list1.size(), list2.size());
   for (size_t i = 0; i < list1.size(); ++i) {
     RemoteDevice device1 = list1[i];
     RemoteDevice device2 = list2[i];
     EXPECT_EQ(device1.public_key, device2.public_key);
   }
 }
 
@@ skipping 11 matching lines @@
   ~MockUnlockManager() override {}
   MOCK_METHOD0(IsUnlockAllowed, bool());
   MOCK_METHOD1(SetRemoteDeviceLifeCycle, void(RemoteDeviceLifeCycle*));
   MOCK_METHOD0(OnLifeCycleStateChanged, void());
   MOCK_METHOD1(OnAuthAttempted, void(ScreenlockBridge::LockHandler::AuthType));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUnlockManager);
 };
 
+// Mock implementation of ProximityAuthPrefManager.
+class MockProximityAuthPrefManager : public ProximityAuthPrefManager {
+ public:
+  MockProximityAuthPrefManager() : ProximityAuthPrefManager(nullptr) {}
+  ~MockProximityAuthPrefManager() override {}
+  MOCK_CONST_METHOD0(GetLastPasswordEntryTimestampMs, int64_t());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockProximityAuthPrefManager);
+};
+
 // Harness for ProximityAuthSystem to make it testable.
 class TestableProximityAuthSystem : public ProximityAuthSystem {
  public:
-  TestableProximityAuthSystem(ScreenlockType screenlock_type,
-                              ProximityAuthClient* proximity_auth_client,
-                              std::unique_ptr<UnlockManager> unlock_manager)
+  TestableProximityAuthSystem(
+      ScreenlockType screenlock_type,
+      ProximityAuthClient* proximity_auth_client,
+      std::unique_ptr<UnlockManager> unlock_manager,
+      std::unique_ptr<base::Clock> clock,
+      std::unique_ptr<ProximityAuthPrefManager> pref_manager)
       : ProximityAuthSystem(screenlock_type,
                             proximity_auth_client,
-                            std::move(unlock_manager)),
+                            std::move(unlock_manager),
+                            std::move(clock),
+                            std::move(pref_manager)),
         life_cycle_(nullptr) {}
   ~TestableProximityAuthSystem() override {}
 
   FakeRemoteDeviceLifeCycle* life_cycle() { return life_cycle_; }
 
  private:
   std::unique_ptr<RemoteDeviceLifeCycle> CreateRemoteDeviceLifeCycle(
       const RemoteDevice& remote_device) override {
     std::unique_ptr<FakeRemoteDeviceLifeCycle> life_cycle(
         new FakeRemoteDeviceLifeCycle(remote_device));
@@ skipping 34 matching lines @@
     LockScreen();
   }
 
   void TearDown() override { UnlockScreen(); }
 
   void InitProximityAuthSystem(ProximityAuthSystem::ScreenlockType type) {
     std::unique_ptr<MockUnlockManager> unlock_manager(
         new NiceMock<MockUnlockManager>());
     unlock_manager_ = unlock_manager.get();
 
+    std::unique_ptr<base::SimpleTestClock> clock =
+        base::MakeUnique<base::SimpleTestClock>();
+    clock_ = clock.get();
+
+    std::unique_ptr<MockProximityAuthPrefManager> pref_manager(
+        new NiceMock<MockProximityAuthPrefManager>());
+    pref_manager_ = pref_manager.get();
+
+    clock_->SetNow(base::Time::FromJavaTime(kTimestampBeforeReauthMs));
+    ON_CALL(*pref_manager_, GetLastPasswordEntryTimestampMs())
+        .WillByDefault(Return(kLastPasswordEntryTimestampMs));
+
     proximity_auth_system_.reset(new TestableProximityAuthSystem(
-        type, &proximity_auth_client_, std::move(unlock_manager)));
+        type, &proximity_auth_client_, std::move(unlock_manager),
+        std::move(clock), std::move(pref_manager)));
   }
 
   void LockScreen() { ScreenlockBridge::Get()->SetLockHandler(&lock_handler_); }
 
   void FocusUser(const std::string& user_id) {
     ScreenlockBridge::Get()->SetFocusedUser(AccountId::FromUserEmail(user_id));
   }
 
   void UnlockScreen() { ScreenlockBridge::Get()->SetLockHandler(nullptr); }
 
   void SimulateSuspend() {
     proximity_auth_system_->OnSuspend();
     proximity_auth_system_->OnSuspendDone();
     task_runner_->RunUntilIdle();
   }
 
   FakeRemoteDeviceLifeCycle* life_cycle() {
     return proximity_auth_system_->life_cycle();
   }
 
   FakeLockHandler lock_handler_;
   NiceMock<MockProximityAuthClient> proximity_auth_client_;
   std::unique_ptr<TestableProximityAuthSystem> proximity_auth_system_;
   MockUnlockManager* unlock_manager_;
+  base::SimpleTestClock* clock_;
+  MockProximityAuthPrefManager* pref_manager_;
 
   RemoteDeviceList user1_remote_devices_;
   RemoteDeviceList user2_remote_devices_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
 
  private:
   ScopedDisableLoggingForTesting disable_logging_;
 
@@ skipping 40 matching lines @@
 
   CompareRemoteDeviceLists(
       user2_remote_devices_,
       proximity_auth_system_->GetRemoteDevicesForUser(account2));
 }
 
 TEST_F(ProximityAuthSystemTest, FocusRegisteredUser) {
   EXPECT_FALSE(life_cycle());
   EXPECT_EQ(std::string(),
             ScreenlockBridge::Get()->focused_account_id().GetUserEmail());
-  EXPECT_FALSE(life_cycle());
 
   RemoteDeviceLifeCycle* unlock_manager_life_cycle = nullptr;
   EXPECT_CALL(*unlock_manager_, SetRemoteDeviceLifeCycle(_))
       .WillOnce(SaveArg<0>(&unlock_manager_life_cycle));
   FocusUser(kUser1);
 
   EXPECT_EQ(life_cycle(), unlock_manager_life_cycle);
   EXPECT_TRUE(life_cycle());
   EXPECT_TRUE(life_cycle()->started());
   EXPECT_EQ(kUser1, life_cycle()->GetRemoteDevice().user_id);
@@ skipping 156 matching lines @@
     EXPECT_CALL(*unlock_manager_, SetRemoteDeviceLifeCycle(NotNull()));
     SimulateSuspend();
   }
 
   EXPECT_EQ(kUser1, life_cycle()->GetRemoteDevice().user_id);
 
   EXPECT_CALL(*unlock_manager_, SetRemoteDeviceLifeCycle(nullptr))
       .Times(AtLeast(1));
 }
 
+TEST_F(ProximityAuthSystemTest, ForcePasswordReauth) {
+  ON_CALL(*pref_manager_, GetLastPasswordEntryTimestampMs())
+      .WillByDefault(Return(kTimestampAfterReauthMs));
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::PASSWORD_REAUTH));
+  FocusUser(kUser1);
+  EXPECT_FALSE(life_cycle());
+}
+
 }  // namespace proximity_auth