[Sync] Add history delete directive type

sync/util/cryptographer_unittest.cc

 // Copyright (c) 2012 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 "sync/util/cryptographer.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
@@ skipping 12 matching lines @@
 using ::testing::Mock;
 using ::testing::StrictMock;
 
 class MockObserver : public Cryptographer::Observer {
  public:
   MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool));
 };
 
 }  // namespace
 
-class SyncCryptographerTest : public ::testing::Test {
+class CryptographerTest : public ::testing::Test {
  protected:
-  SyncCryptographerTest() : cryptographer_(&encryptor_) {}
+  CryptographerTest() : cryptographer_(&encryptor_) {}
 
   FakeEncryptor encryptor_;
   Cryptographer cryptographer_;
 };
 
-TEST_F(SyncCryptographerTest, EmptyCantDecrypt) {
+TEST_F(CryptographerTest, EmptyCantDecrypt) {
   EXPECT_FALSE(cryptographer_.is_ready());
 
   sync_pb::EncryptedData encrypted;
   encrypted.set_key_name("foo");
   encrypted.set_blob("bar");
 
   EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted));
 }
 
-TEST_F(SyncCryptographerTest, EmptyCantEncrypt) {
+TEST_F(CryptographerTest, EmptyCantEncrypt) {
   EXPECT_FALSE(cryptographer_.is_ready());
 
   sync_pb::EncryptedData encrypted;
   sync_pb::PasswordSpecificsData original;
   EXPECT_FALSE(cryptographer_.Encrypt(original, &encrypted));
 }
 
-TEST_F(SyncCryptographerTest, MissingCantDecrypt) {
+TEST_F(CryptographerTest, MissingCantDecrypt) {
   KeyParams params = {"localhost", "dummy", "dummy"};
   cryptographer_.AddKey(params);
   EXPECT_TRUE(cryptographer_.is_ready());
 
   sync_pb::EncryptedData encrypted;
   encrypted.set_key_name("foo");
   encrypted.set_blob("bar");
 
   EXPECT_FALSE(cryptographer_.CanDecrypt(encrypted));
 }
 
-TEST_F(SyncCryptographerTest, CanEncryptAndDecrypt) {
+TEST_F(CryptographerTest, CanEncryptAndDecrypt) {
   KeyParams params = {"localhost", "dummy", "dummy"};
   EXPECT_TRUE(cryptographer_.AddKey(params));
   EXPECT_TRUE(cryptographer_.is_ready());
 
   sync_pb::PasswordSpecificsData original;
   original.set_origin("http://example.com");
   original.set_username_value("azure");
   original.set_password_value("hunter2");
 
   sync_pb::EncryptedData encrypted;
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted));
 
   sync_pb::PasswordSpecificsData decrypted;
   EXPECT_TRUE(cryptographer_.Decrypt(encrypted, &decrypted));
 
   EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString());
 }
 
-TEST_F(SyncCryptographerTest, EncryptOnlyIfDifferent) {
+TEST_F(CryptographerTest, EncryptOnlyIfDifferent) {
   KeyParams params = {"localhost", "dummy", "dummy"};
   EXPECT_TRUE(cryptographer_.AddKey(params));
   EXPECT_TRUE(cryptographer_.is_ready());
 
   sync_pb::PasswordSpecificsData original;
   original.set_origin("http://example.com");
   original.set_username_value("azure");
   original.set_password_value("hunter2");
 
   sync_pb::EncryptedData encrypted;
@@ skipping 10 matching lines @@
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3));
 
   sync_pb::PasswordSpecificsData decrypted;
   EXPECT_TRUE(cryptographer_.Decrypt(encrypted2, &decrypted));
   // encrypted2 should match encrypted, encrypted3 should not (due to salting).
   EXPECT_EQ(encrypted.SerializeAsString(), encrypted2.SerializeAsString());
   EXPECT_NE(encrypted.SerializeAsString(), encrypted3.SerializeAsString());
   EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString());
 }
 
-TEST_F(SyncCryptographerTest, AddKeySetsDefault) {
+TEST_F(CryptographerTest, AddKeySetsDefault) {
   KeyParams params1 = {"localhost", "dummy", "dummy1"};
   EXPECT_TRUE(cryptographer_.AddKey(params1));
   EXPECT_TRUE(cryptographer_.is_ready());
 
   sync_pb::PasswordSpecificsData original;
   original.set_origin("http://example.com");
   original.set_username_value("azure");
   original.set_password_value("hunter2");
 
   sync_pb::EncryptedData encrypted1;
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted1));
   sync_pb::EncryptedData encrypted2;
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted2));
 
   KeyParams params2 = {"localhost", "dummy", "dummy2"};
   EXPECT_TRUE(cryptographer_.AddKey(params2));
   EXPECT_TRUE(cryptographer_.is_ready());
 
   sync_pb::EncryptedData encrypted3;
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted3));
   sync_pb::EncryptedData encrypted4;
   EXPECT_TRUE(cryptographer_.Encrypt(original, &encrypted4));
 
   EXPECT_EQ(encrypted1.key_name(), encrypted2.key_name());
   EXPECT_NE(encrypted1.key_name(), encrypted3.key_name());
   EXPECT_EQ(encrypted3.key_name(), encrypted4.key_name());
 }
 
 // Ensure setting the keystore key works and doesn't modify the default nigori.
-TEST_F(SyncCryptographerTest, SetKeystore) {
+TEST_F(CryptographerTest, SetKeystore) {
   EXPECT_FALSE(cryptographer_.is_initialized());
   EXPECT_FALSE(cryptographer_.HasKeystoreKey());
 
   EXPECT_FALSE(cryptographer_.SetKeystoreKey(""));
   EXPECT_FALSE(cryptographer_.HasKeystoreKey());
 
   EXPECT_TRUE(cryptographer_.SetKeystoreKey("keystore_key"));
   EXPECT_TRUE(cryptographer_.HasKeystoreKey());
   EXPECT_FALSE(cryptographer_.is_initialized());
 }
 
 // Crashes, Bug 55178.
 #if defined(OS_WIN)
 #define MAYBE_EncryptExportDecrypt DISABLED_EncryptExportDecrypt
 #else
 #define MAYBE_EncryptExportDecrypt EncryptExportDecrypt
 #endif
-TEST_F(SyncCryptographerTest, MAYBE_EncryptExportDecrypt) {
+TEST_F(CryptographerTest, MAYBE_EncryptExportDecrypt) {
   sync_pb::EncryptedData nigori;
   sync_pb::EncryptedData encrypted;
 
   sync_pb::PasswordSpecificsData original;
   original.set_origin("http://example.com");
   original.set_username_value("azure");
   original.set_password_value("hunter2");
 
   {
     Cryptographer cryptographer(&encryptor_);
@@ skipping 24 matching lines @@
     EXPECT_EQ(original.SerializeAsString(), decrypted.SerializeAsString());
   }
 }
 
 // Crashes, Bug 55178.
 #if defined(OS_WIN)
 #define MAYBE_PackUnpack DISABLED_PackUnpack
 #else
 #define MAYBE_PackUnpack PackUnpack
 #endif
-TEST_F(SyncCryptographerTest, MAYBE_PackUnpack) {
+TEST_F(CryptographerTest, MAYBE_PackUnpack) {
   Nigori nigori;
   ASSERT_TRUE(nigori.InitByDerivation("example.com", "username", "password"));
   std::string expected_user, expected_encryption, expected_mac;
   ASSERT_TRUE(nigori.ExportKeys(&expected_user, &expected_encryption,
                                 &expected_mac));
 
   std::string token;
   EXPECT_TRUE(cryptographer_.PackBootstrapToken(&nigori, &token));
   EXPECT_TRUE(IsStringUTF8(token));
 
   scoped_ptr<Nigori> unpacked(cryptographer_.UnpackBootstrapToken(token));
   EXPECT_NE(static_cast<Nigori*>(NULL), unpacked.get());
 
   std::string user_key, encryption_key, mac_key;
   ASSERT_TRUE(unpacked->ExportKeys(&user_key, &encryption_key, &mac_key));
 
   EXPECT_EQ(expected_user, user_key);
   EXPECT_EQ(expected_encryption, encryption_key);
   EXPECT_EQ(expected_mac, mac_key);
 }
 
 // Test that bootstrapping the keystore key works and doesn't affect the default
 // nigori.
-TEST_F(SyncCryptographerTest, BootstrapKeystore) {
+TEST_F(CryptographerTest, BootstrapKeystore) {
   std::string token;
   cryptographer_.GetKeystoreKeyBootstrapToken(&token);
   EXPECT_TRUE(token.empty());
 
   cryptographer_.SetKeystoreKey("keystore_key");
   cryptographer_.GetKeystoreKeyBootstrapToken(&token);
   EXPECT_FALSE(token.empty());
 
   Cryptographer cryptographer2(&encryptor_);
   EXPECT_FALSE(cryptographer2.HasKeystoreKey());
   cryptographer2.BootstrapKeystoreKey(token);
   EXPECT_TRUE(cryptographer2.HasKeystoreKey());
   EXPECT_FALSE(cryptographer2.is_initialized());
 }
 
-TEST_F(SyncCryptographerTest, NigoriEncryptionTypes) {
+TEST_F(CryptographerTest, NigoriEncryptionTypes) {
   Cryptographer cryptographer2(&encryptor_);
   sync_pb::NigoriSpecifics nigori;
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
   StrictMock<MockObserver> observer2;
   cryptographer2.AddObserver(&observer2);
 
   // Just set the sensitive types (shouldn't trigger any
   // notifications).
@@ skipping 23 matching lines @@
   EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
    // Receiving an empty nigori should not reset any encrypted types or trigger
    // an observer notification.
    Mock::VerifyAndClearExpectations(&observer);
    nigori = sync_pb::NigoriSpecifics();
    cryptographer_.UpdateEncryptedTypesFromNigori(nigori);
    EXPECT_TRUE(encrypted_types.Equals(cryptographer_.GetEncryptedTypes()));
 }
 
-TEST_F(SyncCryptographerTest, EncryptEverythingExplicit) {
+TEST_F(CryptographerTest, EncryptEverythingExplicit) {
   ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_everything(true);
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
                   HasModelTypes(ModelTypeSet::All()), true));
@@ skipping 16 matching lines @@
        iter.Good(); iter.Inc()) {
     EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer_.RemoveObserver(&observer);
 }
 
-TEST_F(SyncCryptographerTest, EncryptEverythingImplicit) {
+TEST_F(CryptographerTest, EncryptEverythingImplicit) {
   ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
                   HasModelTypes(ModelTypeSet::All()), true));
@@ skipping 16 matching lines @@
        iter.Good(); iter.Inc()) {
     EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer_.RemoveObserver(&observer);
 }
 
-TEST_F(SyncCryptographerTest, UnknownSensitiveTypes) {
+TEST_F(CryptographerTest, UnknownSensitiveTypes) {
   ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   // Explicitly setting encrypt everything should override logic for implicit
   // encrypt everything.
   specifics.set_encrypt_everything(false);
   specifics.set_encrypt_bookmarks(true);
 
   StrictMock<MockObserver> observer;
   cryptographer_.AddObserver(&observer);
 
@@ skipping 25 matching lines @@
         iter.Get() == BOOKMARKS)
       EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
       EXPECT_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer_.RemoveObserver(&observer);
 }
 
 }  // namespace syncer