[Proximity Auth] Port the UnlockManager class.

components/proximity_auth/unlock_manager_unittest.cc

Index: components/proximity_auth/unlock_manager_unittest.cc
diff --git a/components/proximity_auth/unlock_manager_unittest.cc b/components/proximity_auth/unlock_manager_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..78ef93894d36433a4a6de43d7b5f445ca62b979b
--- /dev/null
+++ b/components/proximity_auth/unlock_manager_unittest.cc
@@ -0,0 +1,809 @@
+// 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/unlock_manager.h"
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "components/proximity_auth/client.h"
+#include "components/proximity_auth/controller.h"
+#include "components/proximity_auth/logging/logging.h"
+#include "components/proximity_auth/proximity_auth_client.h"
+#include "components/proximity_auth/proximity_monitor.h"
+#include "components/proximity_auth/remote_status_update.h"
+#include "components/proximity_auth/screenlock_bridge.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(OS_CHROMEOS)
+#include "chromeos/dbus/dbus_thread_manager.h"
+#endif  // defined(OS_CHROMEOS)
+
+using testing::AtLeast;
+using testing::NiceMock;
+using testing::Return;
+using testing::_;
+
+namespace proximity_auth {
+namespace {
+
+// Note that the trust agent state is currently ignored by the UnlockManager
+// implementation.
+RemoteStatusUpdate kRemoteScreenUnlocked = {
+    USER_PRESENT, SECURE_SCREEN_LOCK_ENABLED, TRUST_AGENT_UNSUPPORTED};
+RemoteStatusUpdate kRemoteScreenLocked = {
+    USER_ABSENT, SECURE_SCREEN_LOCK_ENABLED, TRUST_AGENT_UNSUPPORTED};
+RemoteStatusUpdate kRemoteScreenlockDisabled = {
+    USER_PRESENT, SECURE_SCREEN_LOCK_DISABLED, TRUST_AGENT_UNSUPPORTED};
+RemoteStatusUpdate kRemoteScreenlockStateUnknown = {
+    USER_PRESENCE_UNKNOWN, SECURE_SCREEN_LOCK_STATE_UNKNOWN,
+    TRUST_AGENT_UNSUPPORTED};
+
+class MockController : public Controller {
+ public:
+  MockController() {}
+  ~MockController() override {}
+
+  MOCK_CONST_METHOD0(GetState, State());
+  MOCK_METHOD0(GetClient, Client*());
+};
+
+class MockClient : public Client {
+ public:
+  MockClient() {}
+  ~MockClient() override {}
+
+  MOCK_METHOD1(AddObserver, void(ClientObserver* observer));
+  MOCK_METHOD1(RemoveObserver, void(ClientObserver* observer));
+  MOCK_CONST_METHOD0(SupportsSignIn, bool());
+  MOCK_METHOD0(DispatchUnlockEvent, void());
+  MOCK_METHOD1(RequestDecryption, void(const std::string& challenge));
+  MOCK_METHOD0(RequestUnlock, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockClient);
+};
+
+class MockProximityMonitor : public ProximityMonitor {
+ public:
+  MockProximityMonitor() {
+    ON_CALL(*this, GetStrategy())
+        .WillByDefault(Return(ProximityMonitor::Strategy::NONE));
+    ON_CALL(*this, IsUnlockAllowed()).WillByDefault(Return(true));
+    ON_CALL(*this, IsInRssiRange()).WillByDefault(Return(false));
+  }
+  ~MockProximityMonitor() override {}
+
+  MOCK_METHOD0(Start, void());
+  MOCK_METHOD0(Stop, void());
+  MOCK_CONST_METHOD0(GetStrategy, Strategy());
+  MOCK_CONST_METHOD0(IsUnlockAllowed, bool());
+  MOCK_CONST_METHOD0(IsInRssiRange, bool());
+  MOCK_METHOD0(RecordProximityMetricsOnAuthSuccess, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockProximityMonitor);
+};
+
+class MockProximityAuthClient : public ProximityAuthClient {
+ public:
+  MockProximityAuthClient() {}
+  ~MockProximityAuthClient() override {}
+
+  MOCK_CONST_METHOD0(GetAuthenticatedUsername, std::string());
+  MOCK_METHOD0(Lock, void());
+  MOCK_METHOD1(UpdateScreenlockState,
+               void(proximity_auth::ScreenlockState state));
+  MOCK_METHOD1(FinalizeUnlock, void(bool success));
+  MOCK_METHOD1(FinalizeSignIn, void(const std::string& secret));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockProximityAuthClient);
+};
+
+class FakeLockHandler : public ScreenlockBridge::LockHandler {
+ public:
+  FakeLockHandler() {}
+  ~FakeLockHandler() override {}
+
+  // LockHandler:
+  void ShowBannerMessage(const base::string16& message) override {}
+  void ShowUserPodCustomIcon(
+      const std::string& user_email,
+      const ScreenlockBridge::UserPodCustomIconOptions& icon) override {}
+  void HideUserPodCustomIcon(const std::string& user_email) override {}
+  void EnableInput() override {}
+  void SetAuthType(const std::string& user_email,
+                   AuthType auth_type,
+                   const base::string16& auth_value) override {}
+  AuthType GetAuthType(const std::string& user_email) const override {
+    return USER_CLICK;
+  }
+  ScreenType GetScreenType() const override { return LOCK_SCREEN; }
+  void Unlock(const std::string& user_email) override {}
+  void AttemptEasySignin(const std::string& user_email,
+                         const std::string& secret,
+                         const std::string& key_label) override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeLockHandler);
+};
+
+class TestUnlockManager : public UnlockManager {
+ public:
+  TestUnlockManager(ScreenlockType screenlock_type,
+                    scoped_ptr<ProximityMonitor> proximity_monitor,
+                    ProximityAuthClient* proximity_auth_client)
+      : UnlockManager(screenlock_type,
+                      proximity_monitor.Pass(),
+                      proximity_auth_client) {}
+  ~TestUnlockManager() override {}
+
+  using UnlockManager::OnAuthAttempted;
+  using ClientObserver::OnUnlockEventSent;
+  using ClientObserver::OnRemoteStatusUpdate;
+  using ClientObserver::OnDecryptResponse;
+  using ClientObserver::OnUnlockResponse;
+  using ClientObserver::OnDisconnected;
+  using ScreenlockBridge::Observer::OnScreenDidLock;
+  using ScreenlockBridge::Observer::OnScreenDidUnlock;
+  using ScreenlockBridge::Observer::OnFocusedUserChanged;
+};
+
+// Creates a mock Bluetooth adapter and sets it as the global adapter for
+// testing.
+scoped_refptr<device::MockBluetoothAdapter>
+CreateAndRegisterMockBluetoothAdapter() {
+  scoped_refptr<device::MockBluetoothAdapter> adapter =
+      new NiceMock<device::MockBluetoothAdapter>();
+  device::BluetoothAdapterFactory::SetAdapterForTesting(adapter);
+  return adapter;
+}
+
+}  // namespace
+
+class ProximityAuthUnlockManagerTest : public testing::Test {
+ public:
+  ProximityAuthUnlockManagerTest()
+      : bluetooth_adapter_(CreateAndRegisterMockBluetoothAdapter()),
+        proximity_monitor_(nullptr),
+        task_runner_(new base::TestSimpleTaskRunner()),
+        thread_task_runner_handle_(task_runner_) {
+    ON_CALL(*bluetooth_adapter_, IsPowered()).WillByDefault(Return(true));
+    ON_CALL(controller_, GetClient()).WillByDefault(Return(&client_));
+    ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(true));
+
+    ScreenlockBridge::Get()->SetLockHandler(&lock_handler_);
+
+#if defined(OS_CHROMEOS)
+    chromeos::DBusThreadManager::Initialize();
+#endif
+  }
+
+  ~ProximityAuthUnlockManagerTest() override {
+    // Make sure to verify the mock prior to the destruction of the unlock
+    // manager, as otherwise it's impossible to tell whether calls to Stop()
+    // occur as a side-effect of the destruction or from the code intended to be
+    // under test.
+    if (proximity_monitor_)
+      testing::Mock::VerifyAndClearExpectations(proximity_monitor_);
+
+#if defined(OS_CHROMEOS)
+    chromeos::DBusThreadManager::Shutdown();
+#endif
+
+    ScreenlockBridge::Get()->SetLockHandler(nullptr);
+  }
+
+  void CreateUnlockManager(UnlockManager::ScreenlockType screenlock_type) {
+    proximity_monitor_ = new NiceMock<MockProximityMonitor>;
+    unlock_manager_.reset(new TestUnlockManager(
+        screenlock_type, make_scoped_ptr(proximity_monitor_),
+        &proximity_auth_client_));
+  }
+
+  void SimulateUserPresentState() {
+    ON_CALL(controller_, GetState())
+        .WillByDefault(Return(Controller::State::STOPPED));
+    unlock_manager_->SetController(&controller_);
+
+    ON_CALL(controller_, GetState())
+        .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+    unlock_manager_->OnControllerStateChanged();
+
+    unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+  }
+
+  void RunPendingTasks() { task_runner_->RunPendingTasks(); }
+
+ protected:
+  // Mock used for verifying interactions with the Bluetooth subsystem.
+  scoped_refptr<device::MockBluetoothAdapter> bluetooth_adapter_;
+
+  NiceMock<MockProximityAuthClient> proximity_auth_client_;
+  NiceMock<MockController> controller_;
+  NiceMock<MockClient> client_;
+  scoped_ptr<TestUnlockManager> unlock_manager_;
+  // Owned by the |unlock_manager_|.
+  MockProximityMonitor* proximity_monitor_;
+
+ private:
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle thread_task_runner_handle_;
+  FakeLockHandler lock_handler_;
+  ScopedDisableLoggingForTesting disable_logging_;
+};
+
+TEST_F(ProximityAuthUnlockManagerTest, IsUnlockAllowed_InitialState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, IsUnlockAllowed_SessionLock_AllGood) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())

[Tim Song, 2015/07/23 21:32:15]

Wouldn't it be easier to make the controller a fake instead? You don't seem to
be setting any expectations.

[Ilya Sherman, 2015/08/11 23:37:15]

How would you structure the fake?  Provide a set_state() method?  IMO a mock is
slightly easier to use, since there's no need to define a custom interface for
setting the expected state.  But, happy to change this if it's important to you.

+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_TRUE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, IsUnlockAllowed_SignIn_AllGood) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SIGN_IN);
+
+  ON_CALL(controller_, GetState())

[Tim Song, 2015/07/23 21:32:16]

Can't you replace these lines SimulateUserPresentState()? Same goes for the
other test cases below.

[Ilya Sherman, 2015/08/11 23:37:15]

My goal was to have each test case be pretty explicit about what actions it
takes, so that it's clear what's being tested.  So, while you're probably right
that there's unnecessary code duplication, I think it helps make each of the
tests cases clearer on its own.  That said, I can change this if it's important
to you.

+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->OnControllerStateChanged();
+
+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(true));
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_TRUE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_SignIn_ClientDoesNotSupportSignIn) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SIGN_IN);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->OnControllerStateChanged();
+
+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(false));
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, IsUnlockAllowed_SignIn_ClientIsNull) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SIGN_IN);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));

[Tim Song, 2015/07/23 21:32:15]

Don't you need to make controller_->GetClient() return null here as well?

[Ilya Sherman, 2015/08/11 23:37:15]

Done.

+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_DisallowedByProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  ON_CALL(*proximity_monitor_, IsUnlockAllowed()).WillByDefault(Return(false));
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_SecureChannelNotEstablished) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATING));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, IsUnlockAllowed_ControllerIsNull) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  unlock_manager_->SetController(nullptr);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenUnlocked);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_RemoteScreenlockStateLocked) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenLocked);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_RemoteScreenlockStateUnknown) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenlockStateUnknown);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_RemoteScreenlockStateDisabled) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+  unlock_manager_->OnRemoteStatusUpdate(kRemoteScreenlockDisabled);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       IsUnlockAllowed_RemoteScreenlockStateNotYetReceived) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->SetController(&controller_);
+
+  EXPECT_FALSE(unlock_manager_->IsUnlockAllowed());
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, SetController_SetToNull) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::INACTIVE));
+  unlock_manager_->SetController(nullptr);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, SetController_ExistingController) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_, UpdateScreenlockState(_)).Times(0);
+  unlock_manager_->SetController(&controller_);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       SetController_NullThenExistingController) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->SetController(nullptr);

[Tim Song, 2015/07/23 21:32:16]

nit: add an expectation for for the INACTIVE state.

[Ilya Sherman, 2015/08/11 23:37:15]

Done.

+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::AUTHENTICATED));
+  unlock_manager_->SetController(&controller_);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, SetController_AuthenticationFailed) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->SetController(nullptr);

[Tim Song, 2015/07/23 21:32:15]

Why simulate the user present state at all for this test case (and below) if
afterwards, all that work is negated by clearing the controller?

[Ilya Sherman, 2015/08/11 23:37:15]

The idea is to test going from a good state to a bad one.

+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATION_FAILED));
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::PHONE_NOT_AUTHENTICATED));
+  unlock_manager_->SetController(&controller_);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, SetController_WakingUp) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->SetController(nullptr);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::FINDING_CONNECTION));
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  unlock_manager_->SetController(&controller_);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       SetController_NullController_StopsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(*proximity_monitor_, Stop()).Times(AtLeast(1));
+  unlock_manager_->SetController(nullptr);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       SetController_ConnectingController_StopsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  NiceMock<MockController> controller;
+  ON_CALL(controller, GetState())
+      .WillByDefault(Return(Controller::State::FINDING_CONNECTION));
+
+  EXPECT_CALL(*proximity_monitor_, Stop()).Times(AtLeast(1));
+  unlock_manager_->SetController(&controller);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       SetController_ConnectedController_StartsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  NiceMock<MockController> controller;
+  ON_CALL(controller, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+
+  EXPECT_CALL(*proximity_monitor_, Start()).Times(AtLeast(1));
+  unlock_manager_->SetController(&controller);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_SecureChannelEstablished_RegistersAsObserver) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  NiceMock<MockController> controller;
+  ON_CALL(controller, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+
+  EXPECT_CALL(client_, AddObserver(unlock_manager_.get()));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_StartsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  NiceMock<MockController> controller;
+  ON_CALL(controller, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+
+  EXPECT_CALL(*proximity_monitor_, Start()).Times(AtLeast(1));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_StopsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATION_FAILED));
+
+  EXPECT_CALL(*proximity_monitor_, Stop()).Times(AtLeast(1));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_Stopped_UpdatesScreenlockState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::INACTIVE));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_AuthenticationFailed_UpdatesScreenlockState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATION_FAILED));
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::PHONE_NOT_AUTHENTICATED));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_FindingConnection_UpdatesScreenlockState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::FINDING_CONNECTION));
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnControllerStateChanged_Authenticating_UpdatesScreenlockState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATING));
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(
+    ProximityAuthUnlockManagerTest,
+    OnControllerStateChanged_SecureChannelEstablished_UpdatesScreenlockState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  unlock_manager_->OnControllerStateChanged();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnDisconnected_UnregistersAsObserver) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::AUTHENTICATION_FAILED));
+
+  EXPECT_CALL(client_, RemoveObserver(unlock_manager_.get()));
+  unlock_manager_.get()->OnDisconnected();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnScreenDidUnlock_StopsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(*proximity_monitor_, Stop());
+  unlock_manager_.get()->OnScreenDidUnlock(
+      ScreenlockBridge::LockHandler::LOCK_SCREEN);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnScreenDidLock_StartsProximityMonitor) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::STOPPED));
+  unlock_manager_->SetController(&controller_);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::SECURE_CHANNEL_ESTABLISHED));
+  unlock_manager_->OnControllerStateChanged();
+
+  EXPECT_CALL(*proximity_monitor_, Start());
+  unlock_manager_.get()->OnScreenDidLock(
+      ScreenlockBridge::LockHandler::LOCK_SCREEN);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnScreenDidLock_SetsWakingUpState) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_.get()->OnScreenDidUnlock(
+      ScreenlockBridge::LockHandler::LOCK_SCREEN);
+
+  ON_CALL(controller_, GetState())
+      .WillByDefault(Return(Controller::State::FINDING_CONNECTION));
+  unlock_manager_->OnControllerStateChanged();
+
+  EXPECT_CALL(proximity_auth_client_,
+              UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING));
+  unlock_manager_.get()->OnScreenDidLock(
+      ScreenlockBridge::LockHandler::LOCK_SCREEN);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnDecryptResponse_NoAuthAttemptInProgress) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
+  unlock_manager_.get()->OnDecryptResponse(nullptr);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnUnlockEventSent_NoAuthAttemptInProgress) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
+  unlock_manager_.get()->OnUnlockEventSent(true);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnUnlockResponse_NoAuthAttemptInProgress) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
+  unlock_manager_.get()->OnUnlockResponse(true);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnAuthAttempted_NoController) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->SetController(nullptr);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnAuthAttempted_UnlockNotAllowed) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  ON_CALL(*proximity_monitor_, IsUnlockAllowed()).WillByDefault(Return(false));
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnAuthAttempted_NotUserClick) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
+  unlock_manager_->OnAuthAttempted(
+      ScreenlockBridge::LockHandler::EXPAND_THEN_USER_CLICK);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnAuthAttempted_DuplicateCall) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, RequestUnlock());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(client_, RequestUnlock()).Times(0);
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest, OnAuthAttempted_TimesOut) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  // Simulate the timeout period elapsing.
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  RunPendingTasks();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnAuthAttempted_DoesntTimeOutFollowingResponse) {
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_));
+  unlock_manager_->OnUnlockResponse(false);
+
+  // Simulate the timeout period elapsing.
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(_)).Times(0);
+  RunPendingTasks();
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnAuthAttempted_Unlock_SupportsSignIn_UnlockRequestFails) {
+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(true));
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, RequestUnlock());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  unlock_manager_->OnUnlockResponse(false);
+}
+
+TEST_F(
+    ProximityAuthUnlockManagerTest,
+    OnAuthAttempted_Unlock_SupportsSignIn_UnlockRequestSucceeds_UnlockEventSendFails) {

[Tim Song, 2015/07/23 21:32:15]

This formatting is kind of weird. Perhaps there is someway to shorten the name?

[Ilya Sherman, 2015/08/11 23:37:15]

Done.

+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(true));
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, RequestUnlock());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(client_, DispatchUnlockEvent());
+  unlock_manager_->OnUnlockResponse(true);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  unlock_manager_->OnUnlockEventSent(false);
+}
+
+TEST_F(
+    ProximityAuthUnlockManagerTest,
+    OnAuthAttempted_Unlock_SupportsSignIn_UnlockRequestSucceeds_UnlockEventSendSucceeds) {

[Tim Song, 2015/07/23 21:32:15]

same here.

[Ilya Sherman, 2015/08/11 23:37:15]

Done.

+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(true));
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, RequestUnlock());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(client_, DispatchUnlockEvent());
+  unlock_manager_->OnUnlockResponse(true);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(true));
+  unlock_manager_->OnUnlockEventSent(true);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnAuthAttempted_Unlock_DoesntSupportSignIn_UnlockEventSendFails) {
+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(false));
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, DispatchUnlockEvent());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(false));
+  unlock_manager_->OnUnlockEventSent(false);
+}
+
+TEST_F(ProximityAuthUnlockManagerTest,
+       OnAuthAttempted_Unlock_SupportsSignIn_UnlockEventSendSucceeds) {
+  ON_CALL(client_, SupportsSignIn()).WillByDefault(Return(false));
+  CreateUnlockManager(UnlockManager::ScreenlockType::SESSION_LOCK);
+  SimulateUserPresentState();
+
+  EXPECT_CALL(client_, DispatchUnlockEvent());
+  unlock_manager_->OnAuthAttempted(ScreenlockBridge::LockHandler::USER_CLICK);
+
+  EXPECT_CALL(proximity_auth_client_, FinalizeUnlock(true));
+  unlock_manager_->OnUnlockEventSent(true);
+}
+
+}  // namespace proximity_auth