Home | History | Annotate | Download | only in cloud 
      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 "base/base64.h"
      6 #include "base/json/json_reader.h"
      7 #include "base/memory/scoped_ptr.h"
      8 #include "base/test/test_simple_task_runner.h"
      9 #include "base/values.h"
     10 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
     11 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
     12 #include "components/policy/core/common/cloud/policy_header_io_helper.h"
     13 #include "components/policy/core/common/cloud/policy_header_service.h"
     14 #include "net/http/http_request_headers.h"
     15 #include "net/url_request/url_request.h"
     16 #include "net/url_request/url_request_test_util.h"
     17 #include "testing/gtest/include/gtest/gtest.h"
     18 
     19 namespace policy {
     20 using enterprise_management::PolicyData;
     21 
     22 namespace {
     23 const char kDMServerURL[] = "http://server_url";
     24 const char kPolicyHeaderName[] = "Chrome-Policy-Posture";
     25 
     26 class TestCloudPolicyStore : public MockCloudPolicyStore {
     27  public:
     28   void SetPolicy(scoped_ptr<PolicyData> policy) {
     29     policy_ = policy.Pass();
     30     // Notify observers.
     31     NotifyStoreLoaded();
     32   }
     33 };
     34 
     35 class PolicyHeaderServiceTest : public testing::Test {
     36  public:
     37   PolicyHeaderServiceTest() {
     38     task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner());
     39   }
     40   virtual ~PolicyHeaderServiceTest() {}
     41 
     42   virtual void SetUp() OVERRIDE {
     43     service_.reset(new PolicyHeaderService(kDMServerURL,
     44                                            kPolicyVerificationKeyHash,
     45                                            &user_store_,
     46                                            &device_store_));
     47     helper_ = service_->CreatePolicyHeaderIOHelper(task_runner_).Pass();
     48   }
     49 
     50   virtual void TearDown() OVERRIDE {
     51     task_runner_->RunUntilIdle();
     52     // Helper should outlive the service.
     53     service_.reset();
     54     helper_.reset();
     55   }
     56 
     57   void ValidateHeader(const net::HttpRequestHeaders& headers,
     58                       const std::string& expected_dmtoken,
     59                       const std::string& expected_policy_token) {
     60     if (expected_dmtoken.empty()) {
     61       EXPECT_TRUE(headers.IsEmpty());
     62     } else {
     63       // Read header.
     64       std::string header;
     65       EXPECT_TRUE(headers.GetHeader(kPolicyHeaderName, &header));
     66       // Decode the base64 value into JSON.
     67       std::string decoded;
     68       base::Base64Decode(header, &decoded);
     69       // Parse the JSON.
     70       scoped_ptr<base::Value> value(base::JSONReader::Read(decoded));
     71       ASSERT_TRUE(value);
     72       base::DictionaryValue* dict;
     73       EXPECT_TRUE(value->GetAsDictionary(&dict));
     74       // Read the values and verify them vs the expected values.
     75       std::string dm_token;
     76       dict->GetString("user_dmtoken", &dm_token);
     77       EXPECT_EQ(dm_token, expected_dmtoken);
     78       std::string policy_token;
     79       dict->GetString("user_policy_token", &policy_token);
     80       EXPECT_EQ(policy_token, expected_policy_token);
     81     }
     82   }
     83 
     84   base::MessageLoop loop_;
     85   scoped_ptr<PolicyHeaderService> service_;
     86   TestCloudPolicyStore user_store_;
     87   TestCloudPolicyStore device_store_;
     88   scoped_ptr<PolicyHeaderIOHelper> helper_;
     89   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
     90 };
     91 
     92 }  // namespace
     93 
     94 TEST_F(PolicyHeaderServiceTest, TestCreationAndShutdown) {
     95   // Just tests that the objects can be created and shutdown properly.
     96   EXPECT_TRUE(service_);
     97   EXPECT_TRUE(helper_);
     98 }
     99 
    100 TEST_F(PolicyHeaderServiceTest, TestWithAndWithoutPolicyHeader) {
    101   // Set policy - this should push a header to the PolicyHeaderIOHelper.
    102   scoped_ptr<PolicyData> policy(new PolicyData());
    103   std::string expected_dmtoken = "expected_dmtoken";
    104   std::string expected_policy_token = "expected_dmtoken";
    105   policy->set_request_token(expected_dmtoken);
    106   policy->set_policy_token(expected_policy_token);
    107   user_store_.SetPolicy(policy.Pass());
    108   task_runner_->RunUntilIdle();
    109 
    110   net::TestURLRequestContext context;
    111   scoped_ptr<net::URLRequest> request(context.CreateRequest(
    112       GURL(kDMServerURL), net::DEFAULT_PRIORITY, NULL, NULL));
    113   helper_->AddPolicyHeaders(request->url(), request.get());
    114   ValidateHeader(request->extra_request_headers(), expected_dmtoken,
    115                  expected_policy_token);
    116 
    117   // Now blow away the policy data.
    118   user_store_.SetPolicy(scoped_ptr<PolicyData>());
    119   task_runner_->RunUntilIdle();
    120 
    121   scoped_ptr<net::URLRequest> request2(context.CreateRequest(
    122       GURL(kDMServerURL), net::DEFAULT_PRIORITY, NULL, NULL));
    123   helper_->AddPolicyHeaders(request2->url(), request2.get());
    124   ValidateHeader(request2->extra_request_headers(), "", "");
    125 }
    126 
    127 }  // namespace policy
    128