[Password Manager] Add federations to sort key on password page

chrome/browser/ui/passwords/password_manager_presenter_unittest.cc

 // Copyright 2013 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/passwords/password_manager_presenter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 12 matching lines @@
 using testing::Eq;
 using testing::Property;
 
 namespace {
 
 struct SortEntry {
   const char* const origin;
   const char* const username;
   const char* const password;
   const char* const affiliated_web_realm;
+  const char* const federation;
   const int expected_position;
 };
 
 }  // namespace
 
 class MockPasswordUIView : public PasswordUIView {
  public:
   explicit MockPasswordUIView(Profile* profile)
       : profile_(profile), password_manager_presenter_(this) {
     password_manager_presenter_.Initialize();
@@ skipping 40 matching lines @@
     mock_controller_.reset(new MockPasswordUIView(&profile_));
   }
   void AddPasswordEntry(const GURL& origin,
                         const std::string& user_name,
                         const std::string& password);
   void AddPasswordException(const GURL& origin);
   void UpdateLists();
   MockPasswordUIView* GetUIController() { return mock_controller_.get(); }
   void SortAndCheckPositions(const SortEntry test_entries[],
                              size_t number_of_entries,
-                             bool username_and_password_in_key);
+                             PasswordEntryType entry_type);
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<MockPasswordUIView> mock_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordManagerPresenterTest);
 };
 
 void PasswordManagerPresenterTest::AddPasswordEntry(
@@ skipping 18 matching lines @@
 }
 
 void PasswordManagerPresenterTest::UpdateLists() {
   mock_controller_->GetPasswordManagerPresenter()->SetPasswordList();
   mock_controller_->GetPasswordManagerPresenter()->SetPasswordExceptionList();
 }
 
 void PasswordManagerPresenterTest::SortAndCheckPositions(
     const SortEntry test_entries[],
     size_t number_of_entries,
-    bool username_and_password_in_key) {
+    PasswordEntryType entry_type) {
   std::vector<std::unique_ptr<autofill::PasswordForm>> list;
   size_t expected_number_of_unique_entries = 0;
   for (size_t i = 0; i < number_of_entries; i++) {
     const SortEntry& entry = test_entries[i];
     std::unique_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
     form->signon_realm = entry.origin;
     form->origin = GURL(base::ASCIIToUTF16(entry.origin));
-    if (username_and_password_in_key) {
+    if (entry_type == PasswordEntryType::SAVED) {
       form->username_value = base::ASCIIToUTF16(entry.username);
       form->password_value = base::ASCIIToUTF16(entry.password);
+      if (entry.federation != nullptr)
+        form->federation_origin = url::Origin(GURL(entry.federation));
     }
     if (entry.affiliated_web_realm)
       form->affiliated_web_realm = entry.affiliated_web_realm;
     list.push_back(std::move(form));
     if (entry.expected_position >= 0)
       expected_number_of_unique_entries++;
   }
 
   DuplicatesMap duplicates;
   mock_controller_->GetPasswordManagerPresenter()->SortEntriesAndHideDuplicates(
-      &list, &duplicates, username_and_password_in_key);
+      &list, &duplicates, entry_type);
 
   ASSERT_EQ(expected_number_of_unique_entries, list.size());
   ASSERT_EQ(number_of_entries - expected_number_of_unique_entries,
             duplicates.size());
   for (size_t i = 0; i < number_of_entries; i++) {
     const SortEntry& entry = test_entries[i];
     if (entry.expected_position >= 0) {
       SCOPED_TRACE(testing::Message("position in sorted list: ")
                    << entry.expected_position);
       EXPECT_EQ(GURL(base::ASCIIToUTF16(entry.origin)),
                 list[entry.expected_position]->origin);
-      if (username_and_password_in_key) {
+      if (entry_type == PasswordEntryType::SAVED) {
         EXPECT_EQ(base::ASCIIToUTF16(entry.username),
                   list[entry.expected_position]->username_value);
         EXPECT_EQ(base::ASCIIToUTF16(entry.password),
                   list[entry.expected_position]->password_value);
+        if (entry.federation != nullptr)
+          EXPECT_EQ(url::Origin(GURL(entry.federation)),
+                    list[entry.expected_position]->federation_origin);
       }
     }
   }
 }
 
 namespace {
 
 TEST_F(PasswordManagerPresenterTest, UIControllerIsCalled) {
   EXPECT_CALL(*GetUIController(),
               SetPasswordList(Property(
@@ skipping 34 matching lines @@
                   Eq(2u))));
   EXPECT_CALL(*GetUIController(),
               SetPasswordExceptionList(Property(
                   &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
                   Eq(1u))));
   UpdateLists();
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_DifferentOrigins) {
   const SortEntry test_cases[] = {
-      {"http://example-b.com", "user_a", "pwd", nullptr, 2},
-      {"http://example-a.com", "user_a1", "pwd", nullptr, 0},
-      {"http://example-a.com", "user_a2", "pwd", nullptr, 1},
-      {"http://example-c.com", "user_a", "pwd", nullptr, 3}};
-  SortAndCheckPositions(test_cases, arraysize(test_cases), true);
+      {"http://example-b.com", "user_a", "pwd", nullptr, nullptr, 2},
+      {"http://example-a.com", "user_a1", "pwd", nullptr, nullptr, 0},
+      {"http://example-a.com", "user_a2", "pwd", nullptr, nullptr, 1},
+      {"http://example-c.com", "user_a", "pwd", nullptr, nullptr, 3}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_DifferentUsernames) {
   const SortEntry test_cases[] = {
-      {"http://example.com", "user_a", "pwd", nullptr, 0},
-      {"http://example.com", "user_c", "pwd", nullptr, 2},
-      {"http://example.com", "user_b", "pwd", nullptr, 1}};
-  SortAndCheckPositions(test_cases, arraysize(test_cases), true);
+      {"http://example.com", "user_a", "pwd", nullptr, nullptr, 0},
+      {"http://example.com", "user_c", "pwd", nullptr, nullptr, 2},
+      {"http://example.com", "user_b", "pwd", nullptr, nullptr, 1}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_DifferentPasswords) {
   const SortEntry test_cases[] = {
-      {"http://example.com", "user_a", "1", nullptr, 0},
-      {"http://example.com", "user_a", "2", nullptr, 1},
-      {"http://example.com", "user_a", "3", nullptr, 2}};
-  SortAndCheckPositions(test_cases, arraysize(test_cases), true);
+      {"http://example.com", "user_a", "1", nullptr, nullptr, 0},
+      {"http://example.com", "user_a", "2", nullptr, nullptr, 1},
+      {"http://example.com", "user_a", "3", nullptr, nullptr, 2}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_HideDuplicates) {
   const SortEntry test_cases[] = {
-      {"http://example.com", "user_a", "pwd", nullptr, 0},
+      {"http://example.com", "user_a", "pwd", nullptr, nullptr, 0},
       // Different username.
-      {"http://example.com", "user_b", "pwd", nullptr, 2},
+      {"http://example.com", "user_b", "pwd", nullptr, nullptr, 2},
       // Different password.
-      {"http://example.com", "user_a", "secret", nullptr, 1},
+      {"http://example.com", "user_a", "secret", nullptr, nullptr, 1},
       // Different origin.
-      {"http://sub1.example.com", "user_a", "pwd", nullptr, 3},
-      {"http://example.com", "user_a", "pwd", nullptr, -1}  // Hide it.
+      {"http://sub1.example.com", "user_a", "pwd", nullptr, nullptr, 3},
+      {"http://example.com", "user_a", "pwd", nullptr, nullptr, -1}  // Hide it.
   };
-  SortAndCheckPositions(test_cases, arraysize(test_cases), true);
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
 }
 
-TEST_F(PasswordManagerPresenterTest, Sorting_DontUseUsernameAndPasswordInKey) {
+TEST_F(PasswordManagerPresenterTest, Sorting_PasswordExceptions) {
   const SortEntry test_cases[] = {
-      {"http://example-b.com", nullptr, nullptr, nullptr, 1},
-      {"http://example-a.com", nullptr, nullptr, nullptr, 0},
-      {"http://example-a.com", nullptr, nullptr, nullptr, -1},  // Hide it.
-      {"http://example-c.com", nullptr, nullptr, nullptr, 2}};
-  SortAndCheckPositions(test_cases, arraysize(test_cases), false);
+      {"http://example-b.com", nullptr, nullptr, nullptr, nullptr, 1},
+      {"http://example-a.com", nullptr, nullptr, nullptr, nullptr, 0},
+      {"http://example-a.com", nullptr, nullptr, nullptr, nullptr,
+       -1},  // Hide it.
+      {"http://example-c.com", nullptr, nullptr, nullptr, nullptr, 2}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::BLACKLISTED);
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_AndroidCredentials) {
   const SortEntry test_cases[] = {
-      {"https://alpha.com", "user", "secret", nullptr, 0},
-      {"android://hash@com.alpha", "user", "secret", "https://alpha.com", 1},
-      {"android://hash@com.alpha", "user", "secret", "https://alpha.com", -1},
-      {"android://hash@com.alpha", "user", "secret", nullptr, 2},
+      {"https://alpha.com", "user", "secret", nullptr, nullptr, 0},
+      {"android://hash@com.alpha", "user", "secret", "https://alpha.com",
+       nullptr, 1},
+      {"android://hash@com.alpha", "user", "secret", "https://alpha.com",
+       nullptr, -1},
+      {"android://hash@com.alpha", "user", "secret", nullptr, nullptr, 2},
+      {"android://hash@com.betta.android", "user", "secret",
+       "https://betta.com", nullptr, 3},
+      {"android://hash@com.betta.android", "user", "secret", nullptr, nullptr,
+       4}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
+}
 
-      {"android://hash@com.betta.android", "user", "secret",
-       "https://betta.com", 3},
-      {"android://hash@com.betta.android", "user", "secret", nullptr, 4}};
-  SortAndCheckPositions(test_cases, arraysize(test_cases), true);
+TEST_F(PasswordManagerPresenterTest, Sorting_Federations) {
+  const SortEntry test_cases[] = {
+      {"https://example.com", "user", "secret", nullptr, nullptr, 0},
+      {"https://example.com", "user", "secret", nullptr, "https://fed1.com", 1},
+      {"https://example.com", "user", "secret", nullptr, "https://fed2.com",
+       2}};
+  SortAndCheckPositions(test_cases, arraysize(test_cases),
+                        PasswordEntryType::SAVED);
 }
 
 }  // namespace