Credential Management: Rename 'LocalCredential' to 'PasswordCredential' (2/3)

ios/web/web_state/js/credential_util_unittest.mm

 // Copyright 2015 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 "ios/web/web_state/js/credential_util.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "ios/web/public/web_state/credential.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 namespace web {
 namespace {
 
-// "type" value for a DictionaryValue representation of LocalCredential.
-const char* kTestCredentialTypeLocal = "LocalCredential";
+// "type" value for a DictionaryValue representation of PasswordCredential.
+const char* kTestCredentialTypePassword = "PasswordCredential";
 
 // "type" value for a DictionaryValue representation of FederatedCredential.
 const char* kTestCredentialTypeFederated = "FederatedCredential";
 
 // "id" value for a DictionaryValue representation of a credential.
 const char* kTestCredentialID = "foo";
 
 // "name" value for a DictionaryValue representation of a credential.
 const char* kTestCredentialName = "Foo Bar";
 
 // "avatarURL" value for a DictionaryValue representation of a credential.
 const char* kTestCredentialAvatarURL = "https://foo.com/bar.jpg";
 
 // "password" value for a DictionaryValue representation of a credential.
 const char* kTestCredentialPassword = "baz";
 
 // "federationURL" value for a DictionaryValue representation of a credential.
 const char* kTestCredentialFederationURL = "https://foo.com/";
 
-// Returns a Credential with Local type.
-Credential GetTestLocalCredential() {
+// Returns a Credential with Password type.
+Credential GetTestPasswordCredential() {
   Credential credential;
-  credential.type = CredentialType::CREDENTIAL_TYPE_LOCAL;
+  credential.type = CredentialType::CREDENTIAL_TYPE_PASSWORD;
   credential.id = base::ASCIIToUTF16(kTestCredentialID);
   credential.name = base::ASCIIToUTF16(kTestCredentialName);
   credential.avatar_url = GURL(kTestCredentialAvatarURL);
   credential.password = base::ASCIIToUTF16(kTestCredentialPassword);
   return credential;
 }
 
 // Returns a credential with Federated type.
 Credential GetTestFederatedCredential() {
   Credential credential;
   credential.type = CredentialType::CREDENTIAL_TYPE_FEDERATED;
   credential.id = base::ASCIIToUTF16(kTestCredentialID);
   credential.name = base::ASCIIToUTF16(kTestCredentialName);
   credential.avatar_url = GURL(kTestCredentialAvatarURL);
   credential.federation_url = GURL(kTestCredentialFederationURL);
   return credential;
 }
 
 // Returns a value representing the credential returned by
-// |GetTestLocalCredential()|.
-scoped_ptr<base::DictionaryValue> GetTestLocalCredentialDictionaryValue() {
+// |GetTestPasswordCredential()|.
+scoped_ptr<base::DictionaryValue> GetTestPasswordCredentialDictionaryValue() {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
-  value->SetString("type", kTestCredentialTypeLocal);
+  value->SetString("type", kTestCredentialTypePassword);
   value->SetString("id", kTestCredentialID);
   value->SetString("name", kTestCredentialName);
   value->SetString("avatarURL", kTestCredentialAvatarURL);
   value->SetString("password", kTestCredentialPassword);
   return value.Pass();
 }
 
 // Returns a value representing the credential returned by
 // |GetTestFederatedCredentialDictionaryValue()|.
 scoped_ptr<base::DictionaryValue> GetTestFederatedCredentialDictionaryValue() {
@@ skipping 14 matching lines @@
 }
 
 // Tests that parsing a value with a bad type fails.
 TEST(CredentialUtilTest, ParsingValueWithBadTypeFails) {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("type", "FooCredential");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
-// Tests that parsing a correctly-formed value representing a LocalCredential
+// Tests that parsing a correctly-formed value representing a PasswordCredential
 // succeeds.
-TEST(CredentialUtilTest, ParsingLocalCredentialSucceeds) {
+TEST(CredentialUtilTest, ParsingPasswordCredentialSucceeds) {
   Credential credential;
   EXPECT_TRUE(DictionaryValueToCredential(
-      *GetTestLocalCredentialDictionaryValue(), &credential));
-  EXPECT_TRUE(CredentialsEqual(GetTestLocalCredential(), credential));
+      *GetTestPasswordCredentialDictionaryValue(), &credential));
+  EXPECT_TRUE(CredentialsEqual(GetTestPasswordCredential(), credential));
 }
 
-// Tests that parsing a value representing a LocalCredential but with no ID
+// Tests that parsing a value representing a PasswordCredential but with no ID
 // specified fails.
-TEST(CredentialUtilTest, ParsingLocalCredentialWithNoIDFails) {
+TEST(CredentialUtilTest, ParsingPasswordCredentialWithNoIDFails) {
   scoped_ptr<base::DictionaryValue> value(
-      GetTestLocalCredentialDictionaryValue().Pass());
+      GetTestPasswordCredentialDictionaryValue().Pass());
   value->RemoveWithoutPathExpansion("id", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
-// Tests that parsing a value representing a LocalCredential with a badly-
+// Tests that parsing a value representing a PasswordCredential with a badly-
 // formed avatarURL fails.
-TEST(CredentialUtilTest, ParsingLocalCredentialWithBadAvatarURLFails) {
+TEST(CredentialUtilTest, ParsingPasswordCredentialWithBadAvatarURLFails) {
   scoped_ptr<base::DictionaryValue> value(
-      GetTestLocalCredentialDictionaryValue().Pass());
+      GetTestPasswordCredentialDictionaryValue().Pass());
   value->SetString("avatarURL", "foo");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
-// Tests that parsing a value representing a LocalCredential with no password
+// Tests that parsing a value representing a PasswordCredential with no password
 // specified fails.
-TEST(CredentialUtilTest, ParsingLocalCredentialWithNoPasswordFails) {
+TEST(CredentialUtilTest, ParsingPasswordCredentialWithNoPasswordFails) {
   scoped_ptr<base::DictionaryValue> value(
-      GetTestLocalCredentialDictionaryValue().Pass());
+      GetTestPasswordCredentialDictionaryValue().Pass());
   value->Remove("password", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a correctly-formed value representing a
 // FederatedCredential succeeds.
 TEST(CredentialUtilTest, ParsingFederatedCredentialSucceeds) {
   Credential credential;
   EXPECT_TRUE(DictionaryValueToCredential(
@@ skipping 43 matching lines @@
 
 // Tests that serializing a FederatedCredential to a DictionaryValue results
 // in the expected structure.
 TEST(CredentialUtilTest, SerializeFederatedCredential) {
   base::DictionaryValue value;
   Credential credential(GetTestFederatedCredential());
   CredentialToDictionaryValue(credential, &value);
   EXPECT_TRUE(GetTestFederatedCredentialDictionaryValue()->Equals(&value));
 }
 
-// Tests that serializing a LocalCredential to a DictionaryValue results in the
+// Tests that serializing a PasswordCredential to a DictionaryValue results in
+// the
 // expected structure.
-TEST(CredentialUtilTest, SerializeLocalCredential) {
+TEST(CredentialUtilTest, SerializePasswordCredential) {
   base::DictionaryValue value;
-  Credential credential(GetTestLocalCredential());
+  Credential credential(GetTestPasswordCredential());
   CredentialToDictionaryValue(credential, &value);
-  EXPECT_TRUE(GetTestLocalCredentialDictionaryValue()->Equals(&value));
+  EXPECT_TRUE(GetTestPasswordCredentialDictionaryValue()->Equals(&value));
 }
 
 TEST(CredentialUtilTest, SerializeEmptyCredential) {
   base::DictionaryValue value;
   Credential credential;
   CredentialToDictionaryValue(credential, &value);
   EXPECT_TRUE(make_scoped_ptr(new base::DictionaryValue)->Equals(&value));
 }
 
 TEST(CredentialUtilTest, SerializeEmptyCredentialIntoNonEmptyDictionary) {
   base::DictionaryValue value;
   value.SetString("foo", "bar");
   Credential credential;
   CredentialToDictionaryValue(credential, &value);
   EXPECT_TRUE(make_scoped_ptr(new base::DictionaryValue)->Equals(&value));
 }
 
 }  // namespace
 }  // namespace web