Add DeviceSettingsService.

chrome/browser/policy/cloud_policy_validator_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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
   EXPECT_EQ(expected_status, arg0->status());
 };
 
 class CloudPolicyValidatorTest : public testing::Test {
  public:
   CloudPolicyValidatorTest()
       : loop_(MessageLoop::TYPE_UI),
         timestamp_(base::Time::UnixEpoch() +
                    base::TimeDelta::FromMilliseconds(
                        PolicyBuilder::kFakeTimestamp)),
-        file_thread_(content::BrowserThread::FILE, &loop_) {}
+        ignore_missing_timestamp_(false),
+        allow_key_rotation_(true),
+        file_thread_(content::BrowserThread::FILE, &loop_) {
+    policy_.set_new_signing_key(PolicyBuilder::CreateTestNewSigningKey());
+  }
 
   void Validate(testing::Action<void(UserCloudPolicyValidator*)> check_action) {
     std::vector<uint8> public_key;
     ASSERT_TRUE(
         PolicyBuilder::CreateTestSigningKey()->ExportPublicKey(&public_key));
 
     // Create a validator.
     policy_.Build();
     UserCloudPolicyValidator* validator =
         UserCloudPolicyValidator::Create(
             policy_.GetCopy(),
             base::Bind(&CloudPolicyValidatorTest::ValidationCompletion,
                        base::Unretained(this)));
-    validator->ValidateTimestamp(timestamp_, timestamp_);
+    validator->ValidateTimestamp(timestamp_, timestamp_,
+                                 ignore_missing_timestamp_);
     validator->ValidateUsername(PolicyBuilder::kFakeUsername);
     validator->ValidateDomain(PolicyBuilder::kFakeDomain);
     validator->ValidateDMToken(PolicyBuilder::kFakeToken);
     validator->ValidatePolicyType(dm_protocol::kChromeUserPolicyType);
     validator->ValidatePayload();
-    validator->ValidateSignature(std::string(public_key.begin(),
-                                             public_key.end()));
-    validator->ValidateInitialKey();
+    validator->ValidateSignature(
+        std::string(public_key.begin(), public_key.end()),
+        allow_key_rotation_);
+    if (allow_key_rotation_)
+      validator->ValidateInitialKey();
 
     // Run validation and check the result.
     EXPECT_CALL(*this, ValidationCompletion(validator)).WillOnce(check_action);
     validator->StartValidation();
     loop_.RunAllPending();
     Mock::VerifyAndClearExpectations(this);
   }
 
   void CheckSuccessfulValidation(UserCloudPolicyValidator* validator) {
     EXPECT_TRUE(validator->success());
     EXPECT_EQ(policy_.policy().SerializeAsString(),
               validator->policy()->SerializeAsString());
     EXPECT_EQ(policy_.policy_data().SerializeAsString(),
               validator->policy_data()->SerializeAsString());
     EXPECT_EQ(policy_.payload().SerializeAsString(),
               validator->payload()->SerializeAsString());
   }
 
   MessageLoop loop_;
   base::Time timestamp_;
+  bool ignore_missing_timestamp_;
   std::string signing_key_;
+  bool allow_key_rotation_;
 
   UserPolicyBuilder policy_;
 
  private:
   MOCK_METHOD1(ValidationCompletion, void(UserCloudPolicyValidator* validator));
 
   content::TestBrowserThread file_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyValidatorTest);
 };
@@ skipping 16 matching lines @@
 TEST_F(CloudPolicyValidatorTest, ErrorWrongPolicyType) {
   policy_.policy_data().set_policy_type("invalid");
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_WRONG_POLICY_TYPE));
 }
 
 TEST_F(CloudPolicyValidatorTest, ErrorNoTimestamp) {
   policy_.policy_data().clear_timestamp();
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_TIMESTAMP));
 }
 
+TEST_F(CloudPolicyValidatorTest, IgnoreMissingTimestamp) {
+  ignore_missing_timestamp_ = true;
+  policy_.policy_data().clear_timestamp();
+  Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_OK));
+}
+
 TEST_F(CloudPolicyValidatorTest, ErrorOldTimestamp) {
   base::Time timestamp(timestamp_ - base::TimeDelta::FromMinutes(5));
   policy_.policy_data().set_timestamp(
       (timestamp - base::Time::UnixEpoch()).InMilliseconds());
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_TIMESTAMP));
 }
 
 TEST_F(CloudPolicyValidatorTest, ErrorTimestampFromTheFuture) {
   base::Time timestamp(timestamp_ + base::TimeDelta::FromMinutes(5));
   policy_.policy_data().set_timestamp(
@@ skipping 81 matching lines @@
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE));
 }
 
 TEST_F(CloudPolicyValidatorTest, ErrorInvalidPublicKeySignature) {
   policy_.set_signing_key(scoped_ptr<crypto::RSAPrivateKey>());
   policy_.set_new_signing_key(scoped_ptr<crypto::RSAPrivateKey>());
   policy_.policy().set_new_public_key_signature("invalid");
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE));
 }
 
+TEST_F(CloudPolicyValidatorTest, ErrorNoRotationAllowed) {
+  allow_key_rotation_ = false;
+  Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE));
+}
+
+TEST_F(CloudPolicyValidatorTest, NoRotation) {
+  allow_key_rotation_ = false;
+  policy_.set_new_signing_key(scoped_ptr<crypto::RSAPrivateKey>());
+  Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_OK));
+}
+
 }  // namespace
 
 }  // namespace policy