src/components/password_manager/core/browser/password_generation_manager_unittest.cc

   1 // Copyright 2014 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 <vector>
   6
   7 #include "base/prefs/pref_registry_simple.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/prefs/testing_pref_service.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "components/autofill/core/browser/autofill_field.h"
  12 #include "components/autofill/core/browser/autofill_metrics.h"
  13 #include "components/autofill/core/browser/form_structure.h"
  14 #include "components/autofill/core/common/form_data.h"
  15 #include "components/autofill/core/common/form_field_data.h"
  16 #include "components/password_manager/core/browser/password_autofill_manager.h"
  17 #include "components/password_manager/core/browser/password_generation_manager.h"
  18 #include "components/password_manager/core/browser/password_manager.h"
  19 #include "components/password_manager/core/browser/stub_password_manager_client.h"
  20 #include "components/password_manager/core/common/password_manager_pref_names.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "url/gurl.h"
  23
  24 using base::ASCIIToUTF16;
  25
  26 namespace password_manager {
  27
  28 namespace {
  29
  30 class TestPasswordManagerDriver : public PasswordManagerDriver {
  31  public:
  32   TestPasswordManagerDriver(PasswordManagerClient* client)
  33       : password_manager_(client),
  34         password_generation_manager_(client),
  35         password_autofill_manager_(client, NULL),
  36         is_off_the_record_(false) {}
  37   virtual ~TestPasswordManagerDriver() {}
  38
  39   // PasswordManagerDriver implementation.
  40   virtual void FillPasswordForm(const autofill::PasswordFormFillData& form_data)
  41       OVERRIDE {}
  42   virtual bool DidLastPageLoadEncounterSSLErrors() OVERRIDE { return false; }
  43   virtual bool IsOffTheRecord() OVERRIDE { return is_off_the_record_; }
  44   virtual PasswordGenerationManager* GetPasswordGenerationManager() OVERRIDE {
  45     return &password_generation_manager_;
  46   }
  47   virtual PasswordManager* GetPasswordManager() OVERRIDE {
  48     return &password_manager_;
  49   }
  50   virtual autofill::AutofillManager* GetAutofillManager() OVERRIDE {
  51     return NULL;
  52   }
  53   virtual PasswordAutofillManager* GetPasswordAutofillManager() OVERRIDE {
  54     return &password_autofill_manager_;
  55   }
  56   virtual void AllowPasswordGenerationForForm(autofill::PasswordForm* form)
  57       OVERRIDE {}
  58   virtual void AccountCreationFormsFound(
  59       const std::vector<autofill::FormData>& forms) OVERRIDE {
  60     found_account_creation_forms_.insert(
  61         found_account_creation_forms_.begin(), forms.begin(), forms.end());
  62   }
  63   virtual void AcceptPasswordAutofillSuggestion(
  64       const base::string16& username,
  65       const base::string16& password) OVERRIDE {
  66   }
  67
  68   const std::vector<autofill::FormData>& GetFoundAccountCreationForms() {
  69     return found_account_creation_forms_;
  70   }
  71   void set_is_off_the_record(bool is_off_the_record) {
  72     is_off_the_record_ = is_off_the_record;
  73   }
  74
  75  private:
  76   PasswordManager password_manager_;
  77   PasswordGenerationManager password_generation_manager_;
  78   PasswordAutofillManager password_autofill_manager_;
  79   std::vector<autofill::FormData> found_account_creation_forms_;
  80   bool is_off_the_record_;
  81 };
  82
  83 class TestPasswordManagerClient : public StubPasswordManagerClient {
  84  public:
  85   TestPasswordManagerClient(scoped_ptr<PrefService> prefs)
  86       : prefs_(prefs.Pass()), driver_(this), is_sync_enabled_(false) {}
  87
  88   virtual void PromptUserToSavePassword(PasswordFormManager* form_to_save)
  89       OVERRIDE {}
  90   virtual PasswordStore* GetPasswordStore() OVERRIDE { return NULL; }
  91   virtual PrefService* GetPrefs() OVERRIDE { return prefs_.get(); }
  92   virtual PasswordManagerDriver* GetDriver() OVERRIDE { return &driver_; }
  93   virtual void AuthenticateAutofillAndFillForm(
  94       scoped_ptr<autofill::PasswordFormFillData> fill_data) OVERRIDE {}
  95   virtual bool IsPasswordSyncEnabled() OVERRIDE { return is_sync_enabled_; }
  96
  97   void set_is_password_sync_enabled(bool enabled) {
  98     is_sync_enabled_ = enabled;
  99   }
 100
 101  private:
 102   scoped_ptr<PrefService> prefs_;
 103   TestPasswordManagerDriver driver_;
 104   bool is_sync_enabled_;
 105 };
 106
 107 // Unlike the base AutofillMetrics, exposes copy and assignment constructors,
 108 // which are handy for briefer test code.  The AutofillMetrics class is
 109 // stateless, so this is safe.
 110 class TestAutofillMetrics : public autofill::AutofillMetrics {
 111  public:
 112   TestAutofillMetrics() {}
 113   virtual ~TestAutofillMetrics() {}
 114 };
 115
 116 }  // anonymous namespace
 117
 118 class PasswordGenerationManagerTest : public testing::Test {
 119  protected:
 120   virtual void SetUp() OVERRIDE {
 121     // Construct a PrefService and register all necessary prefs before handing
 122     // it off to |client_|, as the initialization flow of |client_| will
 123     // indirectly cause those prefs to be immediately accessed.
 124     scoped_ptr<TestingPrefServiceSimple> prefs(new TestingPrefServiceSimple());
 125     prefs->registry()->RegisterBooleanPref(prefs::kPasswordManagerEnabled,
 126                                            true);
 127     client_.reset(new TestPasswordManagerClient(prefs.PassAs<PrefService>()));
 128   }
 129
 130   virtual void TearDown() OVERRIDE { client_.reset(); }
 131
 132   PasswordGenerationManager* GetGenerationManager() {
 133     return client_->GetDriver()->GetPasswordGenerationManager();
 134   }
 135
 136   TestPasswordManagerDriver* GetTestDriver() {
 137     return static_cast<TestPasswordManagerDriver*>(client_->GetDriver());
 138   }
 139
 140   bool IsGenerationEnabled() {
 141     return GetGenerationManager()->IsGenerationEnabled();
 142   }
 143
 144   void DetectAccountCreationForms(
 145       const std::vector<autofill::FormStructure*>& forms) {
 146     GetGenerationManager()->DetectAccountCreationForms(forms);
 147   }
 148
 149   scoped_ptr<TestPasswordManagerClient> client_;
 150 };
 151
 152 TEST_F(PasswordGenerationManagerTest, IsGenerationEnabled) {
 153   // Enabling the PasswordManager and password sync should cause generation to
 154   // be enabled.
 155   PrefService* prefs = client_->GetPrefs();
 156   prefs->SetBoolean(prefs::kPasswordManagerEnabled, true);
 157   client_->set_is_password_sync_enabled(true);
 158   EXPECT_TRUE(IsGenerationEnabled());
 159
 160   // Disabling password syncing should cause generation to be disabled.
 161   client_->set_is_password_sync_enabled(false);
 162   EXPECT_FALSE(IsGenerationEnabled());
 163
 164   // Disabling the PasswordManager should cause generation to be disabled even
 165   // if syncing is enabled.
 166   prefs->SetBoolean(prefs::kPasswordManagerEnabled, false);
 167   client_->set_is_password_sync_enabled(true);
 168   EXPECT_FALSE(IsGenerationEnabled());
 169 }
 170
 171 TEST_F(PasswordGenerationManagerTest, DetectAccountCreationForms) {
 172   // Setup so that IsGenerationEnabled() returns true.
 173   PrefService* prefs = client_->GetPrefs();
 174   prefs->SetBoolean(prefs::kPasswordManagerEnabled, true);
 175   client_->set_is_password_sync_enabled(true);
 176
 177   autofill::FormData login_form;
 178   login_form.origin = GURL("http://www.yahoo.com/login/");
 179   autofill::FormFieldData username;
 180   username.label = ASCIIToUTF16("username");
 181   username.name = ASCIIToUTF16("login");
 182   username.form_control_type = "text";
 183   login_form.fields.push_back(username);
 184   autofill::FormFieldData password;
 185   password.label = ASCIIToUTF16("password");
 186   password.name = ASCIIToUTF16("password");
 187   password.form_control_type = "password";
 188   login_form.fields.push_back(password);
 189   autofill::FormStructure form1(login_form);
 190   std::vector<autofill::FormStructure*> forms;
 191   forms.push_back(&form1);
 192   autofill::FormData account_creation_form;
 193   account_creation_form.origin = GURL("http://accounts.yahoo.com/");
 194   account_creation_form.fields.push_back(username);
 195   account_creation_form.fields.push_back(password);
 196   autofill::FormFieldData confirm_password;
 197   confirm_password.label = ASCIIToUTF16("confirm_password");
 198   confirm_password.name = ASCIIToUTF16("password");
 199   confirm_password.form_control_type = "password";
 200   account_creation_form.fields.push_back(confirm_password);
 201   autofill::FormStructure form2(account_creation_form);
 202   forms.push_back(&form2);
 203
 204   // Simulate the server response to set the field types.
 205   const char* const kServerResponse =
 206       "<autofillqueryresponse>"
 207       "<field autofilltype=\"9\" />"
 208       "<field autofilltype=\"75\" />"
 209       "<field autofilltype=\"9\" />"
 210       "<field autofilltype=\"76\" />"
 211       "<field autofilltype=\"75\" />"
 212       "</autofillqueryresponse>";
 213   autofill::FormStructure::ParseQueryResponse(
 214       kServerResponse, forms, TestAutofillMetrics());
 215
 216   DetectAccountCreationForms(forms);
 217   EXPECT_EQ(1u, GetTestDriver()->GetFoundAccountCreationForms().size());
 218   EXPECT_EQ(GURL("http://accounts.yahoo.com/"),
 219             GetTestDriver()->GetFoundAccountCreationForms()[0].origin);
 220 }
 221
 222 TEST_F(PasswordGenerationManagerTest, UpdatePasswordSyncStateIncognito) {
 223   // Disable password manager by going incognito. Even though password
 224   // syncing is enabled, generation should still
 225   // be disabled.
 226   GetTestDriver()->set_is_off_the_record(true);
 227   PrefService* prefs = client_->GetPrefs();
 228   prefs->SetBoolean(prefs::kPasswordManagerEnabled, true);
 229   client_->set_is_password_sync_enabled(true);
 230
 231   EXPECT_FALSE(IsGenerationEnabled());
 232 }
 233
 234 }  // namespace password_manager