1// Copyright (c) 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 <vector>
6
7#include "base/callback.h"
8#include "base/json/json_reader.h"
9#include "base/run_loop.h"
10#include "base/values.h"
11#include "chrome/browser/ui/browser.h"
12#include "chrome/browser/ui/tabs/tab_strip_model.h"
13#include "chrome/test/base/in_process_browser_test.h"
14#include "chrome/test/base/ui_test_utils.h"
15#include "components/policy/core/browser/browser_policy_connector.h"
16#include "components/policy/core/common/external_data_fetcher.h"
17#include "components/policy/core/common/mock_configuration_policy_provider.h"
18#include "components/policy/core/common/policy_map.h"
19#include "components/policy/core/common/policy_types.h"
20#include "components/policy/core/common/schema.h"
21#include "content/public/browser/web_contents.h"
22#include "content/public/test/browser_test_utils.h"
23#include "grit/components_strings.h"
24#include "policy/policy_constants.h"
25#include "testing/gmock/include/gmock/gmock.h"
26#include "testing/gtest/include/gtest/gtest.h"
27#include "ui/base/l10n/l10n_util.h"
28#include "url/gurl.h"
29
30using testing::Return;
31using testing::_;
32
33namespace {
34
35std::vector<std::string> PopulateExpectedPolicy(
36    const std::string& name,
37    const std::string& value,
38    const policy::PolicyMap::Entry* metadata,
39    bool unknown) {
40  std::vector<std::string> expected_policy;
41
42  // Populate expected scope.
43  if (metadata) {
44    expected_policy.push_back(l10n_util::GetStringUTF8(
45        metadata->scope == policy::POLICY_SCOPE_MACHINE ?
46            IDS_POLICY_SCOPE_DEVICE : IDS_POLICY_SCOPE_USER));
47  } else {
48    expected_policy.push_back(std::string());
49  }
50
51  // Populate expected level.
52  if (metadata) {
53    expected_policy.push_back(l10n_util::GetStringUTF8(
54        metadata->level == policy::POLICY_LEVEL_RECOMMENDED ?
55            IDS_POLICY_LEVEL_RECOMMENDED : IDS_POLICY_LEVEL_MANDATORY));
56  } else {
57    expected_policy.push_back(std::string());
58  }
59
60  // Populate expected policy name.
61  expected_policy.push_back(name);
62
63  // Populate expected policy value.
64  expected_policy.push_back(value);
65
66  // Populate expected status.
67  if (unknown)
68    expected_policy.push_back(l10n_util::GetStringUTF8(IDS_POLICY_UNKNOWN));
69  else if (metadata)
70    expected_policy.push_back(l10n_util::GetStringUTF8(IDS_POLICY_OK));
71  else
72    expected_policy.push_back(l10n_util::GetStringUTF8(IDS_POLICY_UNSET));
73
74  // Populate expected expanded policy value.
75  expected_policy.push_back(value);
76
77  return expected_policy;
78}
79
80}  // namespace
81
82class PolicyUITest : public InProcessBrowserTest {
83 public:
84  PolicyUITest();
85  virtual ~PolicyUITest();
86
87 protected:
88  // InProcessBrowserTest implementation.
89  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
90
91  void UpdateProviderPolicy(const policy::PolicyMap& policy);
92
93  void VerifyPolicies(const std::vector<std::vector<std::string> >& expected);
94
95 private:
96  policy::MockConfigurationPolicyProvider provider_;
97
98  DISALLOW_COPY_AND_ASSIGN(PolicyUITest);
99};
100
101PolicyUITest::PolicyUITest() {
102}
103
104PolicyUITest::~PolicyUITest() {
105}
106
107void PolicyUITest::SetUpInProcessBrowserTestFixture() {
108  EXPECT_CALL(provider_, IsInitializationComplete(_))
109      .WillRepeatedly(Return(true));
110  policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
111}
112
113void PolicyUITest::UpdateProviderPolicy(const policy::PolicyMap& policy) {
114 provider_.UpdateChromePolicy(policy);
115 base::RunLoop loop;
116 loop.RunUntilIdle();
117}
118
119void PolicyUITest::VerifyPolicies(
120    const std::vector<std::vector<std::string> >& expected_policies) {
121  ui_test_utils::NavigateToURL(browser(), GURL("chrome://policy"));
122
123  // Retrieve the text contents of the policy table cells for all policies.
124  const std::string javascript =
125      "var entries = document.querySelectorAll("
126      "    'section.policy-table-section > * > tbody');"
127      "var policies = [];"
128      "for (var i = 0; i < entries.length; ++i) {"
129      "  var items = entries[i].querySelectorAll('tr > td');"
130      "  var values = [];"
131      "  for (var j = 0; j < items.length; ++j) {"
132      "    var item = items[j];"
133      "    var children = item.getElementsByTagName('div');"
134      "    if (children.length == 1)"
135      "      item = children[0];"
136      "    children = item.getElementsByTagName('span');"
137      "    if (children.length == 1)"
138      "      item = children[0];"
139      "    values.push(item.textContent);"
140      "  }"
141      "  policies.push(values);"
142      "}"
143      "domAutomationController.send(JSON.stringify(policies));";
144  content::WebContents* contents =
145      browser()->tab_strip_model()->GetActiveWebContents();
146  std::string json;
147  ASSERT_TRUE(content::ExecuteScriptAndExtractString(contents, javascript,
148                                                     &json));
149  scoped_ptr<base::Value> value_ptr(base::JSONReader::Read(json));
150  const base::ListValue* actual_policies = NULL;
151  ASSERT_TRUE(value_ptr.get());
152  ASSERT_TRUE(value_ptr->GetAsList(&actual_policies));
153
154  // Verify that the cells contain the expected strings for all policies.
155  ASSERT_EQ(expected_policies.size(), actual_policies->GetSize());
156  for (size_t i = 0; i < expected_policies.size(); ++i) {
157    const std::vector<std::string> expected_policy = expected_policies[i];
158    const base::ListValue* actual_policy;
159    ASSERT_TRUE(actual_policies->GetList(i, &actual_policy));
160    ASSERT_EQ(expected_policy.size(), actual_policy->GetSize());
161    for (size_t j = 0; j < expected_policy.size(); ++j) {
162      std::string value;
163      ASSERT_TRUE(actual_policy->GetString(j, &value));
164      EXPECT_EQ(expected_policy[j], value);
165    }
166  }
167}
168
169IN_PROC_BROWSER_TEST_F(PolicyUITest, SendPolicyNames) {
170  // Verifies that the names of known policies are sent to the UI and processed
171  // there correctly by checking that the policy table contains all policies in
172  // the correct order.
173
174  // Expect that the policy table contains all known policies in alphabetical
175  // order and none of the policies have a set value.
176  std::vector<std::vector<std::string> > expected_policies;
177  policy::Schema chrome_schema =
178      policy::Schema::Wrap(policy::GetChromeSchemaData());
179  ASSERT_TRUE(chrome_schema.valid());
180  for (policy::Schema::Iterator it = chrome_schema.GetPropertiesIterator();
181       !it.IsAtEnd(); it.Advance()) {
182    expected_policies.push_back(
183        PopulateExpectedPolicy(it.key(), std::string(), NULL, false));
184  }
185
186  // Retrieve the contents of the policy table from the UI and verify that it
187  // matches the expectation.
188  VerifyPolicies(expected_policies);
189}
190
191IN_PROC_BROWSER_TEST_F(PolicyUITest, SendPolicyValues) {
192  // Verifies that policy values are sent to the UI and processed there
193  // correctly by setting the values of four known and one unknown policy and
194  // checking that the policy table contains the policy names, values and
195  // metadata in the correct order.
196  policy::PolicyMap values;
197  std::map<std::string, std::string> expected_values;
198
199  // Set the values of four existing policies.
200  base::ListValue* restore_on_startup_urls = new base::ListValue;
201  restore_on_startup_urls->Append(base::Value::CreateStringValue("aaa"));
202  restore_on_startup_urls->Append(base::Value::CreateStringValue("bbb"));
203  restore_on_startup_urls->Append(base::Value::CreateStringValue("ccc"));
204  values.Set(policy::key::kRestoreOnStartupURLs,
205             policy::POLICY_LEVEL_MANDATORY,
206             policy::POLICY_SCOPE_USER,
207             restore_on_startup_urls,
208             NULL);
209  expected_values[policy::key::kRestoreOnStartupURLs] = "aaa,bbb,ccc";
210  values.Set(policy::key::kHomepageLocation,
211             policy::POLICY_LEVEL_MANDATORY,
212             policy::POLICY_SCOPE_MACHINE,
213             base::Value::CreateStringValue("http://google.com"),
214             NULL);
215  expected_values[policy::key::kHomepageLocation] = "http://google.com";
216  values.Set(policy::key::kRestoreOnStartup,
217             policy::POLICY_LEVEL_RECOMMENDED,
218             policy::POLICY_SCOPE_USER,
219             base::Value::CreateIntegerValue(4),
220             NULL);
221  expected_values[policy::key::kRestoreOnStartup] = "4";
222  values.Set(policy::key::kShowHomeButton,
223             policy::POLICY_LEVEL_RECOMMENDED,
224             policy::POLICY_SCOPE_MACHINE,
225             base::Value::CreateBooleanValue(true),
226             NULL);
227  expected_values[policy::key::kShowHomeButton] = "true";
228  // Set the value of a policy that does not exist.
229  const std::string kUnknownPolicy = "NoSuchThing";
230  values.Set(kUnknownPolicy,
231             policy::POLICY_LEVEL_MANDATORY,
232             policy::POLICY_SCOPE_USER,
233             base::Value::CreateBooleanValue(true),
234             NULL);
235  expected_values[kUnknownPolicy] = "true";
236  UpdateProviderPolicy(values);
237
238  // Expect that the policy table contains, in order:
239  // * All known policies whose value has been set, in alphabetical order.
240  // * The unknown policy.
241  // * All known policies whose value has not been set, in alphabetical order.
242  std::vector<std::vector<std::string> > expected_policies;
243  size_t first_unset_position = 0;
244  policy::Schema chrome_schema =
245      policy::Schema::Wrap(policy::GetChromeSchemaData());
246  ASSERT_TRUE(chrome_schema.valid());
247  for (policy::Schema::Iterator props = chrome_schema.GetPropertiesIterator();
248       !props.IsAtEnd(); props.Advance()) {
249    std::map<std::string, std::string>::const_iterator it =
250        expected_values.find(props.key());
251    const std::string value =
252        it == expected_values.end() ? std::string() : it->second;
253    const policy::PolicyMap::Entry* metadata = values.Get(props.key());
254    expected_policies.insert(
255        metadata ? expected_policies.begin() + first_unset_position++ :
256                   expected_policies.end(),
257        PopulateExpectedPolicy(props.key(), value, metadata, false));
258  }
259  expected_policies.insert(
260      expected_policies.begin() + first_unset_position++,
261      PopulateExpectedPolicy(kUnknownPolicy,
262                             expected_values[kUnknownPolicy],
263                             values.Get(kUnknownPolicy),
264                             true));
265
266  // Retrieve the contents of the policy table from the UI and verify that it
267  // matches the expectation.
268  VerifyPolicies(expected_policies);
269}
270