Home | History | Annotate | Download | only in autofill 
      1 // Copyright 2013 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 <string.h>
      6 
      7 #include "base/memory/scoped_ptr.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "chrome/test/base/chrome_render_view_test.h"
     10 #include "components/autofill/content/common/autofill_messages.h"
     11 #include "components/autofill/content/renderer/autofill_agent.h"
     12 #include "components/autofill/content/renderer/test_password_generation_agent.h"
     13 #include "components/autofill/core/common/form_data.h"
     14 #include "testing/gtest/include/gtest/gtest.h"
     15 #include "third_party/WebKit/public/platform/WebString.h"
     16 #include "third_party/WebKit/public/web/WebDocument.h"
     17 #include "third_party/WebKit/public/web/WebLocalFrame.h"
     18 #include "third_party/WebKit/public/web/WebWidget.h"
     19 
     20 using blink::WebDocument;
     21 using blink::WebElement;
     22 using blink::WebInputElement;
     23 using blink::WebNode;
     24 using blink::WebString;
     25 
     26 namespace autofill {
     27 
     28 class PasswordGenerationAgentTest : public ChromeRenderViewTest {
     29  public:
     30   PasswordGenerationAgentTest() {}
     31 
     32   virtual void TearDown() {
     33     LoadHTML("");
     34     ChromeRenderViewTest::TearDown();
     35   }
     36 
     37   void SetNotBlacklistedMessage(const char* form_str) {
     38     autofill::PasswordForm form;
     39     form.origin =
     40         GURL(base::StringPrintf("data:text/html;charset=utf-8,%s", form_str));
     41     AutofillMsg_FormNotBlacklisted msg(0, form);
     42     password_generation_->OnMessageReceived(msg);
     43   }
     44 
     45   void SetAccountCreationFormsDetectedMessage(const char* form_str) {
     46     autofill::FormData form;
     47     form.origin =
     48         GURL(base::StringPrintf("data:text/html;charset=utf-8,%s", form_str));
     49     std::vector<autofill::FormData> forms;
     50     forms.push_back(form);
     51     AutofillMsg_AccountCreationFormsDetected msg(0, forms);
     52     password_generation_->OnMessageReceived(msg);
     53   }
     54 
     55   void ExpectPasswordGenerationAvailable(const char* element_id,
     56                                          bool available) {
     57     WebDocument document = GetMainFrame()->document();
     58     WebElement element =
     59         document.getElementById(WebString::fromUTF8(element_id));
     60     ASSERT_FALSE(element.isNull());
     61     WebInputElement target_element = element.to<WebInputElement>();
     62     ExecuteJavaScript(
     63         base::StringPrintf("document.getElementById('%s').focus();",
     64                            element_id).c_str());
     65     if (available) {
     66       ASSERT_EQ(1u, password_generation_->messages().size());
     67       EXPECT_EQ(AutofillHostMsg_ShowPasswordGenerationPopup::ID,
     68                 password_generation_->messages()[0]->type());
     69     } else {
     70       EXPECT_EQ(0u, password_generation_->messages().size());
     71     }
     72     password_generation_->clear_messages();
     73   }
     74 
     75  private:
     76   DISALLOW_COPY_AND_ASSIGN(PasswordGenerationAgentTest);
     77 };
     78 
     79 const char kSigninFormHTML[] =
     80     "<FORM name = 'blah' action = 'http://www.random.com/'> "
     81     "  <INPUT type = 'text' id = 'username'/> "
     82     "  <INPUT type = 'password' id = 'password'/> "
     83     "  <INPUT type = 'submit' value = 'LOGIN' />"
     84     "</FORM>";
     85 
     86 const char kAccountCreationFormHTML[] =
     87     "<FORM name = 'blah' action = 'http://www.random.com/'> "
     88     "  <INPUT type = 'text' id = 'username'/> "
     89     "  <INPUT type = 'password' id = 'first_password' "
     90     "         autocomplete = 'off' size = 5/>"
     91     "  <INPUT type = 'password' id = 'second_password' size = 5/> "
     92     "  <INPUT type = 'text' id = 'address'/> "
     93     "  <INPUT type = 'submit' value = 'LOGIN' />"
     94     "</FORM>";
     95 
     96 const char kHiddenPasswordAccountCreationFormHTML[] =
     97     "<FORM name = 'blah' action = 'http://www.random.com/'> "
     98     "  <INPUT type = 'text' id = 'username'/> "
     99     "  <INPUT type = 'password' id = 'first_password'/> "
    100     "  <INPUT type = 'password' id = 'second_password' style='display:none'/> "
    101     "  <INPUT type = 'submit' value = 'LOGIN' />"
    102     "</FORM>";
    103 
    104 const char kInvalidActionAccountCreationFormHTML[] =
    105     "<FORM name = 'blah' action = 'invalid'> "
    106     "  <INPUT type = 'text' id = 'username'/> "
    107     "  <INPUT type = 'password' id = 'first_password'/> "
    108     "  <INPUT type = 'password' id = 'second_password'/> "
    109     "  <INPUT type = 'submit' value = 'LOGIN' />"
    110     "</FORM>";
    111 
    112 TEST_F(PasswordGenerationAgentTest, DetectionTest) {
    113   // Don't shown the icon for non account creation forms.
    114   LoadHTML(kSigninFormHTML);
    115   ExpectPasswordGenerationAvailable("password", false);
    116 
    117   // We don't show the decoration yet because the feature isn't enabled.
    118   LoadHTML(kAccountCreationFormHTML);
    119   ExpectPasswordGenerationAvailable("first_password", false);
    120 
    121   // Pretend like We have received message indicating site is not blacklisted,
    122   // and we have received message indicating the form is classified as
    123   // ACCOUNT_CREATION_FORM form Autofill server. We should show the icon.
    124   LoadHTML(kAccountCreationFormHTML);
    125   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    126   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    127   ExpectPasswordGenerationAvailable("first_password", true);
    128 
    129   // This doesn't trigger because hidden password fields are ignored.
    130   LoadHTML(kHiddenPasswordAccountCreationFormHTML);
    131   SetNotBlacklistedMessage(kHiddenPasswordAccountCreationFormHTML);
    132   SetAccountCreationFormsDetectedMessage(
    133       kHiddenPasswordAccountCreationFormHTML);
    134   ExpectPasswordGenerationAvailable("first_password", false);
    135 
    136   // This doesn't trigger because the form action is invalid.
    137   LoadHTML(kInvalidActionAccountCreationFormHTML);
    138   SetNotBlacklistedMessage(kInvalidActionAccountCreationFormHTML);
    139   SetAccountCreationFormsDetectedMessage(kInvalidActionAccountCreationFormHTML);
    140   ExpectPasswordGenerationAvailable("first_password", false);
    141 }
    142 
    143 TEST_F(PasswordGenerationAgentTest, FillTest) {
    144   // Make sure that we are enabled before loading HTML.
    145   LoadHTML(kAccountCreationFormHTML);
    146 
    147   WebDocument document = GetMainFrame()->document();
    148   WebElement element =
    149       document.getElementById(WebString::fromUTF8("first_password"));
    150   ASSERT_FALSE(element.isNull());
    151   WebInputElement first_password_element = element.to<WebInputElement>();
    152   element = document.getElementById(WebString::fromUTF8("second_password"));
    153   ASSERT_FALSE(element.isNull());
    154   WebInputElement second_password_element = element.to<WebInputElement>();
    155 
    156   // Both password fields should be empty.
    157   EXPECT_TRUE(first_password_element.value().isNull());
    158   EXPECT_TRUE(second_password_element.value().isNull());
    159 
    160   base::string16 password = base::ASCIIToUTF16("random_password");
    161   AutofillMsg_GeneratedPasswordAccepted msg(0, password);
    162   password_generation_->OnMessageReceived(msg);
    163 
    164   // Password fields are filled out and set as being autofilled.
    165   EXPECT_EQ(password, first_password_element.value());
    166   EXPECT_EQ(password, second_password_element.value());
    167   EXPECT_TRUE(first_password_element.isAutofilled());
    168   EXPECT_TRUE(second_password_element.isAutofilled());
    169 
    170   // Focus moved to the next input field.
    171   // TODO(zysxqn): Change this back to the address element once Bug 90224
    172   // https://bugs.webkit.org/show_bug.cgi?id=90224 has been fixed.
    173   element = document.getElementById(WebString::fromUTF8("first_password"));
    174   ASSERT_FALSE(element.isNull());
    175   EXPECT_EQ(element, document.focusedElement());
    176 }
    177 
    178 TEST_F(PasswordGenerationAgentTest, EditingTest) {
    179   LoadHTML(kAccountCreationFormHTML);
    180   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    181   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    182 
    183   WebDocument document = GetMainFrame()->document();
    184   WebElement element =
    185       document.getElementById(WebString::fromUTF8("first_password"));
    186   ASSERT_FALSE(element.isNull());
    187   WebInputElement first_password_element = element.to<WebInputElement>();
    188   element = document.getElementById(WebString::fromUTF8("second_password"));
    189   ASSERT_FALSE(element.isNull());
    190   WebInputElement second_password_element = element.to<WebInputElement>();
    191 
    192   base::string16 password = base::ASCIIToUTF16("random_password");
    193   AutofillMsg_GeneratedPasswordAccepted msg(0, password);
    194   password_generation_->OnMessageReceived(msg);
    195 
    196   // Passwords start out the same.
    197   EXPECT_EQ(password, first_password_element.value());
    198   EXPECT_EQ(password, second_password_element.value());
    199 
    200   // After editing the first field they are still the same.
    201   base::string16 edited_password = base::ASCIIToUTF16("edited_password");
    202   first_password_element.setValue(edited_password);
    203   // Cast to WebAutofillClient where textFieldDidChange() is public.
    204   static_cast<blink::WebAutofillClient*>(autofill_agent_)->textFieldDidChange(
    205       first_password_element);
    206   // textFieldDidChange posts a task, so we need to wait until it's been
    207   // processed.
    208   base::MessageLoop::current()->RunUntilIdle();
    209 
    210   EXPECT_EQ(edited_password, first_password_element.value());
    211   EXPECT_EQ(edited_password, second_password_element.value());
    212 }
    213 
    214 TEST_F(PasswordGenerationAgentTest, BlacklistedTest) {
    215   // Did not receive not blacklisted message. Don't show password generation
    216   // icon.
    217   LoadHTML(kAccountCreationFormHTML);
    218   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    219   ExpectPasswordGenerationAvailable("first_password", false);
    220 
    221   // Receive one not blacklisted message for non account creation form. Don't
    222   // show password generation icon.
    223   LoadHTML(kAccountCreationFormHTML);
    224   SetNotBlacklistedMessage(kSigninFormHTML);
    225   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    226   ExpectPasswordGenerationAvailable("first_password", false);
    227 
    228   // Receive one not blackliste message for account creation form. Show password
    229   // generation icon.
    230   LoadHTML(kAccountCreationFormHTML);
    231   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    232   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    233   ExpectPasswordGenerationAvailable("first_password", true);
    234 
    235   // Receive two not blacklisted messages, one is for account creation form and
    236   // the other is not. Show password generation icon.
    237   LoadHTML(kAccountCreationFormHTML);
    238   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    239   SetNotBlacklistedMessage(kSigninFormHTML);
    240   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    241   ExpectPasswordGenerationAvailable("first_password", true);
    242 }
    243 
    244 TEST_F(PasswordGenerationAgentTest, AccountCreationFormsDetectedTest) {
    245   // Did not receive account creation forms detected messege. Don't show
    246   // password generation icon.
    247   LoadHTML(kAccountCreationFormHTML);
    248   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    249   ExpectPasswordGenerationAvailable("first_password", false);
    250 
    251   // Receive the account creation forms detected message. Show password
    252   // generation icon.
    253   LoadHTML(kAccountCreationFormHTML);
    254   SetNotBlacklistedMessage(kAccountCreationFormHTML);
    255   SetAccountCreationFormsDetectedMessage(kAccountCreationFormHTML);
    256   ExpectPasswordGenerationAvailable("first_password", true);
    257 }
    258 
    259 }  // namespace autofill
    260