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 30 using testing::Return; 31 using testing::_; 32 33 namespace { 34 35 std::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 82 class 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 101 PolicyUITest::PolicyUITest() { 102 } 103 104 PolicyUITest::~PolicyUITest() { 105 } 106 107 void PolicyUITest::SetUpInProcessBrowserTestFixture() { 108 EXPECT_CALL(provider_, IsInitializationComplete(_)) 109 .WillRepeatedly(Return(true)); 110 policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_); 111 } 112 113 void PolicyUITest::UpdateProviderPolicy(const policy::PolicyMap& policy) { 114 provider_.UpdateChromePolicy(policy); 115 base::RunLoop loop; 116 loop.RunUntilIdle(); 117 } 118 119 void 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 169 IN_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 191 IN_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(new base::StringValue("aaa")); 202 restore_on_startup_urls->Append(new base::StringValue("bbb")); 203 restore_on_startup_urls->Append(new base::StringValue("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 new base::StringValue("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 new base::FundamentalValue(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 new base::FundamentalValue(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 new base::FundamentalValue(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