chrome/browser/signin/easy_unlock_app_manager_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_app_manager.h"
   6
   7 #include <string>
   8
   9 #include "base/command_line.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "chrome/browser/extensions/component_loader.h"
  13 #include "chrome/browser/extensions/extension_service.h"
  14 #include "chrome/browser/extensions/test_extension_system.h"
  15 #include "chrome/common/extensions/api/easy_unlock_private.h"
  16 #include "chrome/common/extensions/api/screenlock_private.h"
  17 #include "chrome/common/extensions/extension_constants.h"
  18 #include "chrome/test/base/testing_profile.h"
  19 #include "components/proximity_auth/switches.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "extensions/browser/event_router.h"
  22 #include "extensions/browser/event_router_factory.h"
  23 #include "extensions/browser/extension_prefs.h"
  24 #include "extensions/browser/extension_registry.h"
  25 #include "extensions/browser/extension_registry_observer.h"
  26 #include "extensions/browser/process_manager.h"
  27 #include "extensions/browser/process_manager_factory.h"
  28 #include "extensions/common/api/app_runtime.h"
  29 #include "extensions/common/extension.h"
  30 #include "grit/browser_resources.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32
  33 #if defined(OS_CHROMEOS)
  34 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
  35 #include "chrome/browser/chromeos/settings/cros_settings.h"
  36 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  37 #endif
  38
  39 namespace easy_unlock_private_api = extensions::api::easy_unlock_private;
  40 namespace screenlock_private_api = extensions::api::screenlock_private;
  41 namespace app_runtime_api = extensions::core_api::app_runtime;
  42
  43 namespace {
  44
  45 // Sets |*value| to true, also verifying that the value was not previously set.
  46 // Used in tests for verifying that a callback was called.
  47 void VerifyFalseAndSetToTrue(bool* value) {
  48   EXPECT_FALSE(*value);
  49   *value = true;
  50 }
  51
  52 // A ProcessManager that doesn't create background host pages.
  53 class TestProcessManager : public extensions::ProcessManager {
  54  public:
  55   explicit TestProcessManager(content::BrowserContext* context)
  56       : extensions::ProcessManager(
  57             context,
  58             context,
  59             extensions::ExtensionRegistry::Get(context)) {}
  60   ~TestProcessManager() override {}
  61
  62   // ProcessManager overrides:
  63   bool CreateBackgroundHost(const extensions::Extension* extension,
  64                             const GURL& url) override {
  65     return false;
  66   }
  67
  68  private:
  69   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
  70 };
  71
  72 scoped_ptr<KeyedService> CreateTestProcessManager(
  73     content::BrowserContext* context) {
  74   return make_scoped_ptr(new TestProcessManager(context));
  75 }
  76
  77 // Observes extension registry for unload and load events (in that order) of an
  78 // extension with the provided extension id.
  79 // Used to determine if an extension was reloaded.
  80 class ExtensionReloadTracker : public extensions::ExtensionRegistryObserver {
  81  public:
  82   ExtensionReloadTracker(Profile* profile, const std::string& extension_id)
  83       : profile_(profile),
  84         extension_id_(extension_id),
  85         unloaded_(false),
  86         loaded_(false) {
  87     extensions::ExtensionRegistry::Get(profile)->AddObserver(this);
  88   }
  89
  90   ~ExtensionReloadTracker() override {
  91     extensions::ExtensionRegistry::Get(profile_)->RemoveObserver(this);
  92   }
  93
  94   // extension::ExtensionRegistryObserver implementation:
  95   void OnExtensionLoaded(content::BrowserContext* browser_context,
  96                          const extensions::Extension* extension) override {
  97     ASSERT_FALSE(loaded_);
  98     ASSERT_EQ(extension_id_, extension->id());
  99     loaded_ = true;
 100   }
 101
 102   void OnExtensionUnloaded(
 103       content::BrowserContext* browser_context,
 104       const extensions::Extension* extension,
 105       extensions::UnloadedExtensionInfo::Reason reason) override {
 106     ASSERT_FALSE(unloaded_);
 107     ASSERT_EQ(extension_id_, extension->id());
 108     unloaded_ = true;
 109   }
 110
 111   // Whether the extensino was unloaded and loaded during |this| lifetime.
 112   bool HasReloaded() const { return loaded_ && unloaded_; }
 113
 114  private:
 115   Profile* profile_;
 116   std::string extension_id_;
 117   bool unloaded_;
 118   bool loaded_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(ExtensionReloadTracker);
 121 };
 122
 123 // Consumes events dispatched from test event router.
 124 class EasyUnlockAppEventConsumer {
 125  public:
 126   explicit EasyUnlockAppEventConsumer(Profile* profile)
 127       : user_updated_count_(0u),
 128         auth_attempted_count_(0u),
 129         app_launched_count_(0u) {}
 130
 131   ~EasyUnlockAppEventConsumer() {}
 132
 133   // Processes event for test event router.
 134   // It returns whether the event is expected to be dispatched during tests and
 135   // whether it's well formed.
 136   bool ConsumeEvent(const std::string& event_name, base::ListValue* args) {
 137     if (event_name == easy_unlock_private_api::OnUserInfoUpdated::kEventName)
 138       return ConsumeUserInfoUpdated(args);
 139
 140     if (event_name == screenlock_private_api::OnAuthAttempted::kEventName)
 141       return ConsumeAuthAttempted(args);
 142
 143     if (event_name == app_runtime_api::OnLaunched::kEventName)
 144       return ConsumeLaunched(args);
 145
 146     LOG(ERROR) << "Unexpected event: " << event_name;
 147     return false;
 148   }
 149
 150   // Information about encountered events:
 151   size_t user_updated_count() const { return user_updated_count_; }
 152   size_t auth_attempted_count() const { return auth_attempted_count_; }
 153   size_t app_launched_count() const { return app_launched_count_; }
 154
 155   // The data carried by the last UserInfoUpdated event:
 156   std::string user_id() const { return user_id_; }
 157   bool user_logged_in() const { return user_logged_in_; }
 158   bool user_data_ready() const { return user_data_ready_; }
 159
 160  private:
 161   // Processes easyUnlockPrivate.onUserInfoUpdated event.
 162   bool ConsumeUserInfoUpdated(base::ListValue* args) {
 163     if (!args) {
 164       LOG(ERROR) << "No argument list for onUserInfoUpdated event.";
 165       return false;
 166     }
 167
 168     if (args->GetSize() != 1u) {
 169       LOG(ERROR) << "Invalid argument list size for onUserInfoUpdated event: "
 170                  << args->GetSize() << " expected: " << 1u;
 171       return false;
 172     }
 173
 174     base::DictionaryValue* user_info;
 175     if (!args->GetDictionary(0u, &user_info) || !user_info) {
 176       LOG(ERROR) << "Unabled to get event argument as dictionary for "
 177                  << "onUserInfoUpdated event.";
 178       return false;
 179     }
 180
 181     EXPECT_TRUE(user_info->GetString("userId", &user_id_));
 182     EXPECT_TRUE(user_info->GetBoolean("loggedIn", &user_logged_in_));
 183     EXPECT_TRUE(user_info->GetBoolean("dataReady", &user_data_ready_));
 184
 185     ++user_updated_count_;
 186     return true;
 187   }
 188
 189   // Processes screenlockPrivate.onAuthAttempted event.
 190   bool ConsumeAuthAttempted(base::ListValue* args) {
 191     if (!args) {
 192       LOG(ERROR) << "No argument list for onAuthAttempted event";
 193       return false;
 194     }
 195
 196     if (args->GetSize() != 2u) {
 197       LOG(ERROR) << "Invalid argument list size for onAuthAttempted event: "
 198                  << args->GetSize() << " expected: " << 2u;
 199       return false;
 200     }
 201
 202     std::string auth_type;
 203     if (!args->GetString(0u, &auth_type)) {
 204       LOG(ERROR) << "Unable to get first argument as string for "
 205                  << "onAuthAttempted event.";
 206       return false;
 207     }
 208
 209     EXPECT_EQ("userClick", auth_type);
 210     ++auth_attempted_count_;
 211     return true;
 212   }
 213
 214   // Processes app.runtime.onLaunched event.
 215   bool ConsumeLaunched(base::ListValue* args) {
 216     ++app_launched_count_;
 217     return true;
 218   }
 219
 220   size_t user_updated_count_;
 221   size_t auth_attempted_count_;
 222   size_t app_launched_count_;
 223
 224   std::string user_id_;
 225   bool user_logged_in_;
 226   bool user_data_ready_;
 227
 228   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAppEventConsumer);
 229 };
 230
 231 // Event router injected into extension system for the tests. It redirects
 232 // events to EasyUnlockAppEventConsumer.
 233 class TestEventRouter : public extensions::EventRouter {
 234  public:
 235   TestEventRouter(Profile* profile, extensions::ExtensionPrefs* extension_prefs)
 236       : extensions::EventRouter(profile, extension_prefs) {}
 237
 238   ~TestEventRouter() override {}
 239
 240   // extensions::EventRouter implementation:
 241   void BroadcastEvent(scoped_ptr<extensions::Event> event) override {
 242     ASSERT_EQ(screenlock_private_api::OnAuthAttempted::kEventName,
 243               event->event_name);
 244     EXPECT_TRUE(event_consumer_->ConsumeEvent(event->event_name,
 245                                               event->event_args.get()));
 246   }
 247
 248   void DispatchEventToExtension(const std::string& extension_id,
 249                                 scoped_ptr<extensions::Event> event) override {
 250     ASSERT_EQ(extension_misc::kEasyUnlockAppId, extension_id);
 251     EXPECT_TRUE(event_consumer_->ConsumeEvent(event->event_name,
 252                                               event->event_args.get()));
 253   }
 254
 255   void set_event_consumer(EasyUnlockAppEventConsumer* event_consumer) {
 256     event_consumer_ = event_consumer;
 257   }
 258
 259  private:
 260   EasyUnlockAppEventConsumer* event_consumer_;
 261
 262   DISALLOW_COPY_AND_ASSIGN(TestEventRouter);
 263 };
 264
 265 // TestEventRouter factory function
 266 scoped_ptr<KeyedService> TestEventRouterFactoryFunction(
 267     content::BrowserContext* context) {
 268   return make_scoped_ptr(
 269       new TestEventRouter(static_cast<Profile*>(context),
 270                           extensions::ExtensionPrefs::Get(context)));
 271 }
 272
 273 class EasyUnlockAppManagerTest : public testing::Test {
 274  public:
 275   EasyUnlockAppManagerTest()
 276       : event_consumer_(&profile_),
 277         command_line_(base::CommandLine::NO_PROGRAM) {}
 278   ~EasyUnlockAppManagerTest() override {}
 279
 280   void SetUp() override {
 281     base::CommandLine::ForCurrentProcess()->AppendSwitch(
 282         proximity_auth::switches::kForceLoadEasyUnlockAppInTests);
 283     extensions::ExtensionSystem* extension_system = SetUpExtensionSystem();
 284     app_manager_ =
 285         EasyUnlockAppManager::Create(extension_system, IDR_EASY_UNLOCK_MANIFEST,
 286                                      GetAppPath()).Pass();
 287   }
 288
 289  protected:
 290   void SetExtensionSystemReady() {
 291     extensions::TestExtensionSystem* test_extension_system =
 292         static_cast<extensions::TestExtensionSystem*>(
 293             extensions::ExtensionSystem::Get(&profile_));
 294     test_extension_system->SetReady();
 295     base::RunLoop().RunUntilIdle();
 296   }
 297
 298   base::FilePath GetAppPath() {
 299     return extensions::ExtensionPrefs::Get(&profile_)
 300         ->install_directory()
 301         .AppendASCII("easy_unlock");
 302   }
 303
 304  private:
 305   // Initializes test extension system.
 306   extensions::ExtensionSystem* SetUpExtensionSystem() {
 307     extensions::TestExtensionSystem* test_extension_system =
 308         static_cast<extensions::TestExtensionSystem*>(
 309             extensions::ExtensionSystem::Get(&profile_));
 310     extension_service_ = test_extension_system->CreateExtensionService(
 311         &command_line_, base::FilePath() /* install_directory */,
 312         false /* autoupdate_enabled */);
 313
 314     extensions::ProcessManagerFactory::GetInstance()->SetTestingFactory(
 315         &profile_, &CreateTestProcessManager);
 316
 317     event_router_ = static_cast<TestEventRouter*>(
 318         extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
 319             &profile_, &TestEventRouterFactoryFunction));
 320     event_router_->set_event_consumer(&event_consumer_);
 321
 322     extension_service_->component_loader()->
 323         set_ignore_whitelist_for_testing(true);
 324
 325     return test_extension_system;
 326   }
 327
 328  protected:
 329   scoped_ptr<EasyUnlockAppManager> app_manager_;
 330
 331   // Needed by extension system.
 332   content::TestBrowserThreadBundle thread_bundle_;
 333
 334 #if defined(OS_CHROMEOS)
 335   // Cros settings and device settings are needed when creating user manager.
 336   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 337   chromeos::ScopedTestCrosSettings test_cros_settings_;
 338   // Needed for creating ExtensionService.
 339   chromeos::ScopedTestUserManager test_user_manager_;
 340 #endif
 341
 342   TestingProfile profile_;
 343
 344   EasyUnlockAppEventConsumer event_consumer_;
 345   ExtensionService* extension_service_;
 346   TestEventRouter* event_router_;
 347
 348   base::CommandLine command_line_;
 349
 350  private:
 351   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAppManagerTest);
 352 };
 353
 354 TEST_F(EasyUnlockAppManagerTest, LoadAppWhenNotLoaded) {
 355   SetExtensionSystemReady();
 356
 357   // Sanity check for the test: the easy unlock app should not be loaded at
 358   // this point.
 359   ASSERT_FALSE(extension_service_->GetExtensionById(
 360       extension_misc::kEasyUnlockAppId, true));
 361
 362   app_manager_->LoadApp();
 363
 364   ASSERT_TRUE(extension_service_->GetExtensionById(
 365       extension_misc::kEasyUnlockAppId, false));
 366   EXPECT_TRUE(
 367       extension_service_->IsExtensionEnabled(extension_misc::kEasyUnlockAppId));
 368 }
 369
 370 TEST_F(EasyUnlockAppManagerTest, LoadAppWhenAlreadyLoaded) {
 371   SetExtensionSystemReady();
 372
 373   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 374                                               GetAppPath());
 375
 376   app_manager_->LoadApp();
 377
 378   ASSERT_TRUE(extension_service_->GetExtensionById(
 379       extension_misc::kEasyUnlockAppId, false));
 380 }
 381
 382 TEST_F(EasyUnlockAppManagerTest, LoadAppPreviouslyDisabled) {
 383   SetExtensionSystemReady();
 384
 385   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 386                                               GetAppPath());
 387   extension_service_->DisableExtension(extension_misc::kEasyUnlockAppId,
 388                                        extensions::Extension::DISABLE_RELOAD);
 389
 390   ASSERT_TRUE(extension_service_->GetExtensionById(
 391       extension_misc::kEasyUnlockAppId, true));
 392   ASSERT_FALSE(
 393       extension_service_->IsExtensionEnabled(extension_misc::kEasyUnlockAppId));
 394
 395   app_manager_->LoadApp();
 396
 397   ASSERT_TRUE(extension_service_->GetExtensionById(
 398       extension_misc::kEasyUnlockAppId, false));
 399 }
 400
 401 TEST_F(EasyUnlockAppManagerTest, ReloadApp) {
 402   SetExtensionSystemReady();
 403
 404   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 405                                               GetAppPath());
 406
 407   ExtensionReloadTracker reload_tracker(&profile_,
 408                                         extension_misc::kEasyUnlockAppId);
 409   ASSERT_FALSE(reload_tracker.HasReloaded());
 410
 411   app_manager_->ReloadApp();
 412
 413   EXPECT_TRUE(reload_tracker.HasReloaded());
 414   EXPECT_TRUE(extension_service_->GetExtensionById(
 415       extension_misc::kEasyUnlockAppId, false));
 416 }
 417
 418 TEST_F(EasyUnlockAppManagerTest, ReloadAppDisabled) {
 419   SetExtensionSystemReady();
 420
 421   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 422                                               GetAppPath());
 423   extension_service_->DisableExtension(extension_misc::kEasyUnlockAppId,
 424                                        extensions::Extension::DISABLE_RELOAD);
 425   ExtensionReloadTracker reload_tracker(&profile_,
 426                                         extension_misc::kEasyUnlockAppId);
 427   ASSERT_FALSE(reload_tracker.HasReloaded());
 428
 429   app_manager_->ReloadApp();
 430
 431   EXPECT_FALSE(reload_tracker.HasReloaded());
 432   EXPECT_TRUE(extension_service_->GetExtensionById(
 433       extension_misc::kEasyUnlockAppId, true));
 434   EXPECT_FALSE(
 435       extension_service_->IsExtensionEnabled(extension_misc::kEasyUnlockAppId));
 436 }
 437
 438 TEST_F(EasyUnlockAppManagerTest, DisableApp) {
 439   SetExtensionSystemReady();
 440
 441   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 442                                               GetAppPath());
 443   EXPECT_TRUE(extension_service_->GetExtensionById(
 444       extension_misc::kEasyUnlockAppId, false));
 445
 446   app_manager_->DisableAppIfLoaded();
 447
 448   EXPECT_TRUE(extension_service_->GetExtensionById(
 449       extension_misc::kEasyUnlockAppId, true));
 450   EXPECT_FALSE(
 451       extension_service_->IsExtensionEnabled(extension_misc::kEasyUnlockAppId));
 452 }
 453
 454 TEST_F(EasyUnlockAppManagerTest, DisableAppWhenNotLoaded) {
 455   SetExtensionSystemReady();
 456
 457   EXPECT_FALSE(extension_service_->GetExtensionById(
 458       extension_misc::kEasyUnlockAppId, true));
 459
 460   app_manager_->DisableAppIfLoaded();
 461
 462   EXPECT_FALSE(extension_service_->GetExtensionById(
 463       extension_misc::kEasyUnlockAppId, true));
 464
 465   extension_service_->component_loader()->Add(IDR_EASY_UNLOCK_MANIFEST,
 466                                               GetAppPath());
 467   EXPECT_TRUE(extension_service_->GetExtensionById(
 468       extension_misc::kEasyUnlockAppId, false));
 469 }
 470
 471 TEST_F(EasyUnlockAppManagerTest, EnsureReady) {
 472   bool ready = false;
 473   app_manager_->EnsureReady(base::Bind(&VerifyFalseAndSetToTrue, &ready));
 474
 475   base::RunLoop().RunUntilIdle();
 476   ASSERT_FALSE(ready);
 477
 478   SetExtensionSystemReady();
 479   ASSERT_TRUE(ready);
 480 }
 481
 482 TEST_F(EasyUnlockAppManagerTest, EnsureReadyAfterExtesionSystemReady) {
 483   SetExtensionSystemReady();
 484
 485   bool ready = false;
 486   app_manager_->EnsureReady(base::Bind(&VerifyFalseAndSetToTrue, &ready));
 487
 488   base::RunLoop().RunUntilIdle();
 489   ASSERT_TRUE(ready);
 490 }
 491
 492 TEST_F(EasyUnlockAppManagerTest, LaunchSetup) {
 493   SetExtensionSystemReady();
 494
 495   ASSERT_EQ(0u, event_consumer_.app_launched_count());
 496
 497   app_manager_->LoadApp();
 498   app_manager_->LaunchSetup();
 499
 500   EXPECT_EQ(1u, event_consumer_.app_launched_count());
 501 }
 502
 503 TEST_F(EasyUnlockAppManagerTest, LaunchSetupWhenDisabled) {
 504   SetExtensionSystemReady();
 505
 506   ASSERT_EQ(0u, event_consumer_.app_launched_count());
 507
 508   app_manager_->LoadApp();
 509   app_manager_->DisableAppIfLoaded();
 510
 511   app_manager_->LaunchSetup();
 512
 513   EXPECT_EQ(0u, event_consumer_.app_launched_count());
 514 }
 515
 516 TEST_F(EasyUnlockAppManagerTest, LaunchSetupWhenNotLoaded) {
 517   SetExtensionSystemReady();
 518
 519   ASSERT_EQ(0u, event_consumer_.app_launched_count());
 520
 521   app_manager_->LaunchSetup();
 522
 523   EXPECT_EQ(0u, event_consumer_.app_launched_count());
 524 }
 525
 526 TEST_F(EasyUnlockAppManagerTest, SendUserUpdated) {
 527   SetExtensionSystemReady();
 528
 529   app_manager_->LoadApp();
 530   event_router_->AddLazyEventListener(
 531       easy_unlock_private_api::OnUserInfoUpdated::kEventName,
 532       extension_misc::kEasyUnlockAppId);
 533
 534   ASSERT_EQ(0u, event_consumer_.user_updated_count());
 535
 536   EXPECT_TRUE(app_manager_->SendUserUpdatedEvent("user", true /* logged_in */,
 537                                                  false /* data_ready */));
 538
 539   EXPECT_EQ(1u, event_consumer_.user_updated_count());
 540
 541   EXPECT_EQ("user", event_consumer_.user_id());
 542   EXPECT_TRUE(event_consumer_.user_logged_in());
 543   EXPECT_FALSE(event_consumer_.user_data_ready());
 544 }
 545
 546 TEST_F(EasyUnlockAppManagerTest, SendUserUpdatedInvertedFlags) {
 547   SetExtensionSystemReady();
 548
 549   app_manager_->LoadApp();
 550   event_router_->AddLazyEventListener(
 551       easy_unlock_private_api::OnUserInfoUpdated::kEventName,
 552       extension_misc::kEasyUnlockAppId);
 553
 554   ASSERT_EQ(0u, event_consumer_.user_updated_count());
 555
 556   EXPECT_TRUE(app_manager_->SendUserUpdatedEvent("user", false /* logged_in */,
 557                                                  true /* data_ready */));
 558
 559   EXPECT_EQ(1u, event_consumer_.user_updated_count());
 560
 561   EXPECT_EQ("user", event_consumer_.user_id());
 562   EXPECT_FALSE(event_consumer_.user_logged_in());
 563   EXPECT_TRUE(event_consumer_.user_data_ready());
 564 }
 565
 566 TEST_F(EasyUnlockAppManagerTest, SendUserUpdatedNoRegisteredListeners) {
 567   SetExtensionSystemReady();
 568
 569   app_manager_->LoadApp();
 570
 571   ASSERT_EQ(0u, event_consumer_.user_updated_count());
 572
 573   EXPECT_FALSE(app_manager_->SendUserUpdatedEvent("user", true, true));
 574   EXPECT_EQ(0u, event_consumer_.user_updated_count());
 575 }
 576
 577 TEST_F(EasyUnlockAppManagerTest, SendUserUpdatedAppDisabled) {
 578   SetExtensionSystemReady();
 579
 580   app_manager_->LoadApp();
 581   event_router_->AddLazyEventListener(
 582       easy_unlock_private_api::OnUserInfoUpdated::kEventName,
 583       extension_misc::kEasyUnlockAppId);
 584   app_manager_->DisableAppIfLoaded();
 585
 586   ASSERT_EQ(0u, event_consumer_.user_updated_count());
 587
 588   EXPECT_FALSE(app_manager_->SendUserUpdatedEvent("user", true, true));
 589   EXPECT_EQ(0u, event_consumer_.user_updated_count());
 590 }
 591
 592 TEST_F(EasyUnlockAppManagerTest, SendAuthAttempted) {
 593   SetExtensionSystemReady();
 594
 595   app_manager_->LoadApp();
 596   event_router_->AddLazyEventListener(
 597       screenlock_private_api::OnAuthAttempted::kEventName,
 598       extension_misc::kEasyUnlockAppId);
 599
 600   ASSERT_EQ(0u, event_consumer_.user_updated_count());
 601
 602   EXPECT_TRUE(app_manager_->SendAuthAttemptEvent());
 603   EXPECT_EQ(1u, event_consumer_.auth_attempted_count());
 604 }
 605
 606 TEST_F(EasyUnlockAppManagerTest, SendAuthAttemptedNoRegisteredListeners) {
 607   SetExtensionSystemReady();
 608
 609   app_manager_->LoadApp();
 610
 611   ASSERT_EQ(0u, event_consumer_.auth_attempted_count());
 612
 613   EXPECT_FALSE(app_manager_->SendAuthAttemptEvent());
 614   EXPECT_EQ(0u, event_consumer_.auth_attempted_count());
 615 }
 616
 617 TEST_F(EasyUnlockAppManagerTest, SendAuthAttemptedAppDisabled) {
 618   SetExtensionSystemReady();
 619
 620   app_manager_->LoadApp();
 621   event_router_->AddLazyEventListener(
 622       screenlock_private_api::OnAuthAttempted::kEventName,
 623       extension_misc::kEasyUnlockAppId);
 624   app_manager_->DisableAppIfLoaded();
 625
 626   ASSERT_EQ(0u, event_consumer_.auth_attempted_count());
 627
 628   EXPECT_FALSE(app_manager_->SendAuthAttemptEvent());
 629   EXPECT_EQ(0u, event_consumer_.auth_attempted_count());
 630 }
 631
 632 }  // namespace