Settings People Revamp: Easy Unlock: Add basic UI

chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc

 // Copyright 2016 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 "chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_web_ui.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace settings {
 
 namespace {
 
 class FakeEasyUnlockService : public EasyUnlockService {
  public:
   explicit FakeEasyUnlockService(Profile* profile)
-      : EasyUnlockService(profile), turn_off_status_(IDLE), is_allowed_(true) {}
+      : EasyUnlockService(profile),
+        turn_off_status_(IDLE),
+        is_allowed_(true),
+        is_enabled_(false) {}
 
   TurnOffFlowStatus GetTurnOffFlowStatus() const override {
     return turn_off_status_;
   }
 
   bool IsAllowed() const override { return is_allowed_; }
+  void set_is_allowed(bool is_allowed) { is_allowed_ = is_allowed; }
 
-  void set_is_allowed(bool is_allowed) { is_allowed_ = is_allowed; }
+  bool IsEnabled() const override { return is_enabled_; }
+  void set_is_enabled(bool is_enabled) { is_enabled_ = is_enabled; }
 
   void RunTurnOffFlow() override {
     turn_off_status_ = PENDING;
     NotifyTurnOffOperationStatusChanged();
   }
 
   void ResetTurnOffFlow() override {
     turn_off_status_ = IDLE;
     NotifyTurnOffOperationStatusChanged();
   }
@@ skipping 26 matching lines @@
   void SetAutoPairingResult(bool success, const std::string& error) override {}
 
   void InitializeInternal() override {}
   void ShutdownInternal() override {}
   bool IsAllowedInternal() const override { return false; }
   void OnWillFinalizeUnlock(bool success) override {}
   void OnSuspendDoneInternal() override {}
 
   TurnOffFlowStatus turn_off_status_;
   bool is_allowed_;
+  bool is_enabled_;
 };
 
 class TestEasyUnlockSettingsHandler : public EasyUnlockSettingsHandler {
  public:
   explicit TestEasyUnlockSettingsHandler(Profile* profile)
       : EasyUnlockSettingsHandler(profile) {}
 
   using EasyUnlockSettingsHandler::set_web_ui;
 };
 
@@ skipping 16 matching lines @@
     profile_ = builder.Build();
   }
 
   Profile* profile() { return profile_.get(); }
   content::TestWebUI* web_ui() { return &web_ui_; }
   FakeEasyUnlockService* fake_easy_unlock_service() {
     return static_cast<FakeEasyUnlockService*>(
         EasyUnlockService::Get(profile_.get()));
   }
 
+  void VerifyEnabledStatusCallback(size_t expected_total_calls,
+                                   bool expected_status) {
+    std::string event;
+    bool status;
+
+    EXPECT_EQ(expected_total_calls, web_ui_.call_data().size());
+
+    const content::TestWebUI::CallData& data = *web_ui_.call_data().back();
+    EXPECT_EQ("cr.webUIListenerCallback", data.function_name());
+    ASSERT_TRUE(data.arg1()->GetAsString(&event));
+    EXPECT_EQ("easy-unlock-enabled-status", event);
+    ASSERT_TRUE(data.arg2()->GetAsBoolean(&status));
+
+    EXPECT_EQ(expected_status, status);
+  }
+
   void VerifyTurnOffStatusCallback(size_t expected_total_calls,
                                    const std::string& expected_status) {
     std::string event;
     std::string status;
 
     EXPECT_EQ(expected_total_calls, web_ui_.call_data().size());
 
     const content::TestWebUI::CallData& data = *web_ui_.call_data().back();
     EXPECT_EQ("cr.webUIListenerCallback", data.function_name());
     ASSERT_TRUE(data.arg1()->GetAsString(&event));
@@ skipping 16 matching lines @@
   content::WebUIDataSource::Add(profile(), data_source);
   handler.reset(
       EasyUnlockSettingsHandler::Create(data_source, profile()));
   EXPECT_TRUE(handler.get());
 
   fake_easy_unlock_service()->set_is_allowed(false);
   handler.reset(EasyUnlockSettingsHandler::Create(data_source, profile()));
   EXPECT_FALSE(handler.get());
 }
 
+TEST_F(EasyUnlockSettingsHandlerTest, EnabledStatus) {
+  scoped_ptr<EasyUnlockSettingsHandler> handler;
+  handler.reset(new TestEasyUnlockSettingsHandler(profile()));
+  handler->set_web_ui(web_ui());
+
+  // Test the C++ -> JS push path.
+  handler->SendEnabledStatus();
+  VerifyEnabledStatusCallback(1U, false);
+
+  fake_easy_unlock_service()->set_is_enabled(true);
+  handler->SendEnabledStatus();
+  VerifyEnabledStatusCallback(2U, true);
+
+  // Test the JS -> C++ -> JS callback path.
+  base::ListValue list_args;
+  list_args.Append(new base::StringValue("test-callback-id"));
+  handler->HandleGetEnabledStatus(&list_args);
+
+  std::string callback_id;
+  bool enabled_status;
+
+  EXPECT_EQ(3U, web_ui()->call_data().size());
+
+  const content::TestWebUI::CallData& data = *web_ui()->call_data().back();
+  EXPECT_EQ("cr.webUIResponse", data.function_name());
+
+  ASSERT_TRUE(data.arg1()->GetAsString(&callback_id));
+  EXPECT_EQ("test-callback-id", callback_id);
+
+  ASSERT_TRUE(data.arg2()->GetAsBoolean(&enabled_status));
+  EXPECT_TRUE(enabled_status);
+}
+
 TEST_F(EasyUnlockSettingsHandlerTest, TurnOffStatus) {
   scoped_ptr<EasyUnlockSettingsHandler> handler;
   handler.reset(new TestEasyUnlockSettingsHandler(profile()));
   handler->set_web_ui(web_ui());
 
+  // Send an initial status query to turn on service observer.
+  base::ListValue list_args;
+  list_args.Append(new base::StringValue("test-callback-id"));
+  handler->HandleGetEnabledStatus(&list_args);
+  EXPECT_EQ(1U, web_ui()->call_data().size());
+
   handler->HandleGetTurnOffFlowStatus(nullptr);
-  VerifyTurnOffStatusCallback(1U, "idle");
+  VerifyTurnOffStatusCallback(2U, "idle");
 
   handler->HandleRequestTurnOff(nullptr);
-  VerifyTurnOffStatusCallback(2U, "pending");
+  VerifyTurnOffStatusCallback(3U, "pending");
 
   handler->HandleGetTurnOffFlowStatus(nullptr);
-  VerifyTurnOffStatusCallback(3U, "pending");
+  VerifyTurnOffStatusCallback(4U, "pending");
 
   handler->HandlePageDismissed(nullptr);
-  VerifyTurnOffStatusCallback(4U, "idle");
+  VerifyTurnOffStatusCallback(5U, "idle");
 
   fake_easy_unlock_service()->SetTurnOffFailForTest();
-  VerifyTurnOffStatusCallback(5U, "server-error");
+  VerifyTurnOffStatusCallback(6U, "server-error");
 
   handler->HandleGetTurnOffFlowStatus(nullptr);
-  VerifyTurnOffStatusCallback(6U, "server-error");
+  VerifyTurnOffStatusCallback(7U, "server-error");
 }
 
 }  // namespace settings
 }  // namespace chromeos