chrome/browser/signin/easy_unlock_auth_attempt_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/signin/easy_unlock_auth_attempt.h"
   6
   7 #include "base/macros.h"
   8 #include "chrome/browser/signin/easy_unlock_app_manager.h"
   9 #include "components/proximity_auth/screenlock_bridge.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 #if defined(OS_CHROMEOS)
  13 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
  14 #endif
  15
  16 namespace {
  17
  18 // Fake user ids used in tests.
  19 const char kTestUser1[] = "user1";
  20 const char kTestUser2[] = "user2";
  21
  22 #if defined(OS_CHROMEOS)
  23 const unsigned char kSecret[] = {
  24     0x7c, 0x85, 0x82, 0x7d, 0x00, 0x1f, 0x6a, 0x29, 0x2f, 0xc4, 0xb5, 0x60,
  25     0x08, 0x9b, 0xb0, 0x5b
  26 };
  27 #endif
  28
  29 const unsigned char kSessionKey[] = {
  30     0xc3, 0xd9, 0x83, 0x16, 0x52, 0xde, 0x99, 0xd7, 0x4e, 0x60, 0xf9, 0xec,
  31     0xa8, 0x9c, 0x0e, 0xbe
  32 };
  33
  34 const unsigned char kWrappedSecret[] = {
  35     0x3a, 0xea, 0x51, 0xd9, 0x64, 0x64, 0xe1, 0xcd, 0xd8, 0xee, 0x99, 0xf5,
  36     0xb1, 0xd4, 0x9f, 0xc4, 0x28, 0xd6, 0xfd, 0x69, 0x0b, 0x9e, 0x06, 0x21,
  37     0xfc, 0x40, 0x1f, 0xeb, 0x75, 0x64, 0x52, 0xd8
  38 };
  39
  40 #if defined(OS_CHROMEOS)
  41 std::string GetSecret() {
  42   return std::string(reinterpret_cast<const char*>(kSecret),
  43                      arraysize(kSecret));
  44 }
  45 #endif
  46
  47 std::string GetWrappedSecret() {
  48   return std::string(reinterpret_cast<const char*>(kWrappedSecret),
  49                      arraysize(kWrappedSecret));
  50 }
  51
  52 std::string GetSessionKey() {
  53   return std::string(reinterpret_cast<const char*>(kSessionKey),
  54                      arraysize(kSessionKey));
  55 }
  56
  57 // Fake app manager used by the EasyUnlockAuthAttempt during tests.
  58 // It tracks screenlockPrivate.onAuthAttempted events.
  59 class FakeAppManager : public EasyUnlockAppManager {
  60  public:
  61   FakeAppManager()
  62       : auth_attempt_count_(0u), auth_attempt_should_fail_(false) {}
  63   ~FakeAppManager() override {}
  64
  65   void EnsureReady(const base::Closure& ready_callback) override {
  66     ADD_FAILURE() << "Not reached";
  67   }
  68
  69   void LaunchSetup() override { ADD_FAILURE() << "Not reached"; }
  70
  71   void LoadApp() override { ADD_FAILURE() << "Not reached"; }
  72
  73   void DisableAppIfLoaded() override { ADD_FAILURE() << "Not reached"; }
  74
  75   void ReloadApp() override { ADD_FAILURE() << "Not reached"; }
  76
  77   bool SendUserUpdatedEvent(const std::string& user_id,
  78                             bool is_logged_in,
  79                             bool data_ready) override {
  80     ADD_FAILURE() << "Not reached";
  81     return false;
  82   }
  83
  84   bool SendAuthAttemptEvent() override {
  85     ++auth_attempt_count_;
  86     return !auth_attempt_should_fail_;
  87   }
  88
  89   size_t auth_attempt_count() const { return auth_attempt_count_; }
  90
  91   void set_auth_attempt_should_fail(bool value) {
  92     auth_attempt_should_fail_ = value;
  93   }
  94
  95  private:
  96   size_t auth_attempt_count_;
  97   bool auth_attempt_should_fail_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(FakeAppManager);
 100 };
 101
 102 // Fake lock handler to be used in these tests.
 103 class TestLockHandler : public proximity_auth::ScreenlockBridge::LockHandler {
 104  public:
 105   // The state of unlock/signin procedure.
 106   enum AuthState {
 107     STATE_NONE,
 108     STATE_ATTEMPTING_UNLOCK,
 109     STATE_UNLOCK_CANCELED,
 110     STATE_UNLOCK_DONE,
 111     STATE_ATTEMPTING_SIGNIN,
 112     STATE_SIGNIN_CANCELED,
 113     STATE_SIGNIN_DONE
 114   };
 115
 116   explicit TestLockHandler(const std::string& user_id)
 117       : state_(STATE_NONE), auth_type_(USER_CLICK), user_id_(user_id) {}
 118
 119   ~TestLockHandler() override {}
 120
 121   void set_state(AuthState value) { state_ = value; }
 122   AuthState state() const { return state_; }
 123
 124   // Changes the user associated with the lock handler.
 125   // Caller should make sure that |state_| is also appropriately updated.
 126   void set_user_id(const std::string& value) { user_id_ = value; }
 127
 128   // Sets the secret that is expected to be sent to |AttemptEasySignin|
 129   void set_expected_secret(const std::string& value) {
 130     expected_secret_ = value;
 131   }
 132
 133   // Not using |SetAuthType| to make sure it's not called during tests.
 134   void set_auth_type(AuthType value) { auth_type_ = value; }
 135
 136   // proximity_auth::ScreenlockBridge::LockHandler implementation:
 137   void ShowBannerMessage(const base::string16& message) override {
 138     ADD_FAILURE() << "Should not be reached.";
 139   }
 140
 141   void ShowUserPodCustomIcon(
 142       const std::string& user_email,
 143       const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions& icon)
 144       override {
 145     ADD_FAILURE() << "Should not be reached.";
 146   }
 147
 148   void HideUserPodCustomIcon(const std::string& user_email) override {
 149     ADD_FAILURE() << "Should not be reached.";
 150   }
 151
 152   void EnableInput() override {
 153     ASSERT_EQ(STATE_ATTEMPTING_UNLOCK, state_);
 154     state_ = STATE_UNLOCK_CANCELED;
 155   }
 156
 157   void SetAuthType(const std::string& user_email,
 158                    AuthType auth_type,
 159                    const base::string16& auth_value) override {
 160     ADD_FAILURE() << "Should not be reached.";
 161   }
 162
 163   AuthType GetAuthType(const std::string& user_email) const override {
 164     return auth_type_;
 165   }
 166
 167   ScreenType GetScreenType() const override {
 168     // Return an arbitrary value; this is not used by the test code.
 169     return LOCK_SCREEN;
 170   }
 171
 172   void Unlock(const std::string& user_email) override {
 173     ASSERT_EQ(user_id_, user_email);
 174     ASSERT_EQ(STATE_ATTEMPTING_UNLOCK, state_);
 175     state_ = STATE_UNLOCK_DONE;
 176   }
 177
 178   void AttemptEasySignin(const std::string& user_email,
 179                          const std::string& secret,
 180                          const std::string& key_label) override {
 181 #if defined(OS_CHROMEOS)
 182     ASSERT_EQ(user_id_, user_email);
 183
 184     ASSERT_EQ(STATE_ATTEMPTING_SIGNIN, state_);
 185     if (secret.empty()) {
 186       state_ = STATE_SIGNIN_CANCELED;
 187     } else {
 188       ASSERT_EQ(expected_secret_, secret);
 189       ASSERT_EQ(chromeos::EasyUnlockKeyManager::GetKeyLabel(0u), key_label);
 190       state_ = STATE_SIGNIN_DONE;
 191     }
 192 #else  // if !defined(OS_CHROMEOS)
 193     ADD_FAILURE() << "Should not be reached.";
 194 #endif
 195   }
 196
 197  private:
 198   AuthState state_;
 199   AuthType auth_type_;
 200   std::string user_id_;
 201   std::string expected_secret_;
 202
 203   DISALLOW_COPY_AND_ASSIGN(TestLockHandler);
 204 };
 205
 206 class EasyUnlockAuthAttemptUnlockTest : public testing::Test {
 207  public:
 208   EasyUnlockAuthAttemptUnlockTest() {}
 209   ~EasyUnlockAuthAttemptUnlockTest() override {}
 210
 211   void SetUp() override {
 212     app_manager_.reset(new FakeAppManager());
 213     auth_attempt_.reset(new EasyUnlockAuthAttempt(
 214         app_manager_.get(), kTestUser1, EasyUnlockAuthAttempt::TYPE_UNLOCK,
 215         EasyUnlockAuthAttempt::FinalizedCallback()));
 216   }
 217
 218   void TearDown() override {
 219     proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 220     auth_attempt_.reset();
 221   }
 222
 223  protected:
 224   void InitScreenLock() {
 225     lock_handler_.reset(new TestLockHandler(kTestUser1));
 226     lock_handler_->set_state(TestLockHandler::STATE_ATTEMPTING_UNLOCK);
 227     proximity_auth::ScreenlockBridge::Get()->SetLockHandler(
 228         lock_handler_.get());
 229   }
 230
 231   scoped_ptr<EasyUnlockAuthAttempt> auth_attempt_;
 232   scoped_ptr<FakeAppManager> app_manager_;
 233   scoped_ptr<TestLockHandler> lock_handler_;
 234
 235  private:
 236   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAuthAttemptUnlockTest);
 237 };
 238
 239 TEST_F(EasyUnlockAuthAttemptUnlockTest, StartWhenNotLocked) {
 240   ASSERT_FALSE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 241
 242   EXPECT_FALSE(auth_attempt_->Start());
 243   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 244 }
 245
 246 TEST_F(EasyUnlockAuthAttemptUnlockTest, StartWhenAuthTypeIsPassword) {
 247   InitScreenLock();
 248   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 249   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 250
 251   lock_handler_->set_auth_type(
 252       proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
 253
 254   EXPECT_FALSE(auth_attempt_->Start());
 255
 256   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 257   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 258 }
 259
 260 TEST_F(EasyUnlockAuthAttemptUnlockTest,
 261        StartWhenDispatchingAuthAttemptEventFails) {
 262   InitScreenLock();
 263   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 264   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 265
 266   app_manager_->set_auth_attempt_should_fail(true);
 267
 268   EXPECT_FALSE(auth_attempt_->Start());
 269
 270   EXPECT_EQ(1u, app_manager_->auth_attempt_count());
 271   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 272 }
 273
 274 TEST_F(EasyUnlockAuthAttemptUnlockTest, ResetBeforeFinalizeUnlock) {
 275   InitScreenLock();
 276   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 277   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 278
 279   ASSERT_TRUE(auth_attempt_->Start());
 280
 281   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 282   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 283
 284   auth_attempt_.reset();
 285
 286   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 287 }
 288
 289 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeUnlockFailure) {
 290   InitScreenLock();
 291   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 292   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 293
 294   ASSERT_TRUE(auth_attempt_->Start());
 295
 296   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 297   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 298
 299   auth_attempt_->FinalizeUnlock(kTestUser1, false);
 300
 301   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 302 }
 303
 304 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeSigninCalled) {
 305   InitScreenLock();
 306   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 307   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 308
 309   ASSERT_TRUE(auth_attempt_->Start());
 310
 311   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 312   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 313
 314   // Wrapped secret and key should be irrelevant in this case.
 315   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
 316                                 GetSessionKey());
 317
 318   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 319 }
 320
 321 TEST_F(EasyUnlockAuthAttemptUnlockTest, UnlockSucceeds) {
 322   InitScreenLock();
 323   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 324   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 325
 326   ASSERT_TRUE(auth_attempt_->Start());
 327
 328   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 329   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 330
 331   auth_attempt_->FinalizeUnlock(kTestUser1, true);
 332
 333   ASSERT_EQ(TestLockHandler::STATE_UNLOCK_DONE, lock_handler_->state());
 334 }
 335
 336 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeUnlockCalledForWrongUser) {
 337   InitScreenLock();
 338   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 339   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 340
 341   ASSERT_TRUE(auth_attempt_->Start());
 342
 343   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 344   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 345
 346   auth_attempt_->FinalizeUnlock(kTestUser2, true);
 347
 348   // If FinalizeUnlock is called for an incorrect user, it should be ignored
 349   // rather than cancelling the authentication.
 350   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 351
 352   // When FinalizeUnlock is called for the correct user, it should work as
 353   // expected.
 354   auth_attempt_->FinalizeUnlock(kTestUser1, true);
 355
 356   ASSERT_EQ(TestLockHandler::STATE_UNLOCK_DONE, lock_handler_->state());
 357 }
 358
 359 #if defined(OS_CHROMEOS)
 360 class EasyUnlockAuthAttemptSigninTest : public testing::Test {
 361  public:
 362   EasyUnlockAuthAttemptSigninTest() {}
 363   ~EasyUnlockAuthAttemptSigninTest() override {}
 364
 365   void SetUp() override {
 366     app_manager_.reset(new FakeAppManager());
 367     auth_attempt_.reset(new EasyUnlockAuthAttempt(
 368         app_manager_.get(), kTestUser1, EasyUnlockAuthAttempt::TYPE_SIGNIN,
 369         EasyUnlockAuthAttempt::FinalizedCallback()));
 370   }
 371
 372   void TearDown() override {
 373     proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 374     auth_attempt_.reset();
 375   }
 376
 377  protected:
 378   void InitScreenLock() {
 379     lock_handler_.reset(new TestLockHandler(kTestUser1));
 380     lock_handler_->set_state(TestLockHandler::STATE_ATTEMPTING_SIGNIN);
 381     proximity_auth::ScreenlockBridge::Get()->SetLockHandler(
 382         lock_handler_.get());
 383   }
 384
 385   scoped_ptr<EasyUnlockAuthAttempt> auth_attempt_;
 386   scoped_ptr<FakeAppManager> app_manager_;
 387   scoped_ptr<TestLockHandler> lock_handler_;
 388
 389  private:
 390   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAuthAttemptSigninTest);
 391 };
 392
 393 TEST_F(EasyUnlockAuthAttemptSigninTest, StartWhenNotLocked) {
 394   ASSERT_FALSE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 395
 396   EXPECT_FALSE(auth_attempt_->Start());
 397   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 398 }
 399
 400 TEST_F(EasyUnlockAuthAttemptSigninTest, StartWhenAuthTypeIsPassword) {
 401   InitScreenLock();
 402   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 403   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 404
 405   lock_handler_->set_auth_type(
 406       proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
 407
 408   EXPECT_FALSE(auth_attempt_->Start());
 409
 410   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 411   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 412 }
 413
 414 TEST_F(EasyUnlockAuthAttemptSigninTest,
 415        StartWhenDispatchingAuthAttemptEventFails) {
 416   InitScreenLock();
 417   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 418   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 419
 420   app_manager_->set_auth_attempt_should_fail(true);
 421
 422   EXPECT_FALSE(auth_attempt_->Start());
 423
 424   EXPECT_EQ(1u, app_manager_->auth_attempt_count());
 425   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 426 }
 427
 428 TEST_F(EasyUnlockAuthAttemptSigninTest, ResetBeforeFinalizeSignin) {
 429   InitScreenLock();
 430   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 431   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 432
 433   ASSERT_TRUE(auth_attempt_->Start());
 434
 435   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 436   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 437
 438   auth_attempt_.reset();
 439
 440   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 441 }
 442
 443 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninWithEmtpySecret) {
 444   InitScreenLock();
 445   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 446   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 447
 448   ASSERT_TRUE(auth_attempt_->Start());
 449
 450   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 451   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 452
 453   auth_attempt_->FinalizeSignin(kTestUser1, "", GetSessionKey());
 454
 455   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 456 }
 457
 458 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninWithEmtpyKey) {
 459   InitScreenLock();
 460   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 461   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 462
 463   ASSERT_TRUE(auth_attempt_->Start());
 464
 465   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 466   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 467
 468   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(), "");
 469
 470   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 471 }
 472
 473 TEST_F(EasyUnlockAuthAttemptSigninTest, SigninSuccess) {
 474   InitScreenLock();
 475   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 476   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 477
 478   ASSERT_TRUE(auth_attempt_->Start());
 479
 480   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 481   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 482
 483   lock_handler_->set_expected_secret(GetSecret());
 484   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
 485                                 GetSessionKey());
 486
 487   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_DONE, lock_handler_->state());
 488 }
 489
 490 TEST_F(EasyUnlockAuthAttemptSigninTest, WrongWrappedSecret) {
 491   InitScreenLock();
 492   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 493   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 494
 495   ASSERT_TRUE(auth_attempt_->Start());
 496
 497   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 498   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 499
 500   auth_attempt_->FinalizeSignin(kTestUser1, "wrong_secret", GetSessionKey());
 501
 502   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 503 }
 504
 505 TEST_F(EasyUnlockAuthAttemptSigninTest, InvalidSessionKey) {
 506   InitScreenLock();
 507   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 508   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 509
 510   ASSERT_TRUE(auth_attempt_->Start());
 511
 512   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 513   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 514
 515   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(), "invalid_key");
 516
 517   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 518 }
 519
 520 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeUnlockCalled) {
 521   InitScreenLock();
 522   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 523   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 524
 525   ASSERT_TRUE(auth_attempt_->Start());
 526
 527   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 528   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 529
 530   auth_attempt_->FinalizeUnlock(kTestUser1, true);
 531
 532   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 533 }
 534
 535 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninCalledForWrongUser) {
 536   InitScreenLock();
 537   ASSERT_TRUE(proximity_auth::ScreenlockBridge::Get()->IsLocked());
 538   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 539
 540   ASSERT_TRUE(auth_attempt_->Start());
 541
 542   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
 543   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 544
 545   lock_handler_->set_expected_secret(GetSecret());
 546
 547   auth_attempt_->FinalizeSignin(kTestUser2, GetWrappedSecret(),
 548                                 GetSessionKey());
 549
 550   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 551
 552   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
 553                                 GetSessionKey());
 554
 555   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_DONE, lock_handler_->state());
 556 }
 557 #endif  // defined(OS_CHROMEOS)
 558
 559 }  // namespace