| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 | |
| 7 """Unittests for grit.format.policy_templates.writers.admx_writer.""" | |
| 8 | |
| 9 | |
| 10 import os | |
| 11 import sys | |
| 12 import unittest | |
| 13 if __name__ == '__main__': | |
| 14 sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) | |
| 15 | |
| 16 | |
| 17 from grit.format.policy_templates.writers import admx_writer | |
| 18 from grit.format.policy_templates.writers import xml_writer_base_unittest | |
| 19 from xml.dom import minidom | |
| 20 | |
| 21 | |
| 22 class AdmxWriterUnittest(xml_writer_base_unittest.XmlWriterBaseTest): | |
| 23 | |
| 24 def _CreateDocumentElement(self): | |
| 25 dom_impl = minidom.getDOMImplementation('') | |
| 26 doc = dom_impl.createDocument(None, 'root', None) | |
| 27 return doc.documentElement | |
| 28 | |
| 29 def setUp(self): | |
| 30 # Writer configuration. This dictionary contains parameter used by the ADMX | |
| 31 # Writer | |
| 32 config = { | |
| 33 'win_group_policy_class': 'TestClass', | |
| 34 'win_supported_os': 'SUPPORTED_TESTOS', | |
| 35 'win_reg_mandatory_key_name': 'Software\\Policies\\Test', | |
| 36 'win_reg_recommended_key_name': 'Software\\Policies\\Test\\Recommended', | |
| 37 'win_mandatory_category_path': ['test_category'], | |
| 38 'win_recommended_category_path': ['test_recommended_category'], | |
| 39 'admx_namespace': 'ADMXWriter.Test.Namespace', | |
| 40 'admx_prefix': 'test_prefix', | |
| 41 'build': 'test_product', | |
| 42 } | |
| 43 self.writer = admx_writer.GetWriter(config) | |
| 44 self.writer.Init() | |
| 45 | |
| 46 def _GetPoliciesElement(self, doc): | |
| 47 node_list = doc.getElementsByTagName('policies') | |
| 48 self.assertTrue(node_list.length == 1) | |
| 49 return node_list.item(0) | |
| 50 | |
| 51 def _GetCategoriesElement(self, doc): | |
| 52 node_list = doc.getElementsByTagName('categories') | |
| 53 self.assertTrue(node_list.length == 1) | |
| 54 return node_list.item(0) | |
| 55 | |
| 56 def testEmpty(self): | |
| 57 self.writer.BeginTemplate() | |
| 58 self.writer.EndTemplate() | |
| 59 | |
| 60 output = self.writer.GetTemplateText() | |
| 61 expected_output = ( | |
| 62 '<?xml version="1.0" ?>\n' | |
| 63 '<policyDefinitions revision="1.0" schemaVersion="1.0">\n' | |
| 64 ' <policyNamespaces>\n' | |
| 65 ' <target namespace="ADMXWriter.Test.Namespace"' | |
| 66 ' prefix="test_prefix"/>\n' | |
| 67 ' <using namespace="Microsoft.Policies.Windows" prefix="windows"/>\n' | |
| 68 ' </policyNamespaces>\n' | |
| 69 ' <resources minRequiredRevision="1.0"/>\n' | |
| 70 ' <supportedOn>\n' | |
| 71 ' <definitions>\n' | |
| 72 ' <definition displayName="' | |
| 73 '$(string.SUPPORTED_TESTOS)" name="SUPPORTED_TESTOS"/>\n' | |
| 74 ' </definitions>\n' | |
| 75 ' </supportedOn>\n' | |
| 76 ' <categories>\n' | |
| 77 ' <category displayName="$(string.test_category)"' | |
| 78 ' name="test_category"/>\n' | |
| 79 ' <category displayName="$(string.test_recommended_category)"' | |
| 80 ' name="test_recommended_category"/>\n' | |
| 81 ' </categories>\n' | |
| 82 ' <policies/>\n' | |
| 83 '</policyDefinitions>') | |
| 84 self.AssertXMLEquals(output, expected_output) | |
| 85 | |
| 86 def testEmptyVersion(self): | |
| 87 self.writer.config['version'] = '39.0.0.0' | |
| 88 self.writer.BeginTemplate() | |
| 89 self.writer.EndTemplate() | |
| 90 | |
| 91 output = self.writer.GetTemplateText() | |
| 92 expected_output = ( | |
| 93 '<?xml version="1.0" ?>\n' | |
| 94 '<policyDefinitions revision="1.0" schemaVersion="1.0">\n' | |
| 95 ' <!--test_product version: 39.0.0.0-->\n' | |
| 96 ' <policyNamespaces>\n' | |
| 97 ' <target namespace="ADMXWriter.Test.Namespace"' | |
| 98 ' prefix="test_prefix"/>\n' | |
| 99 ' <using namespace="Microsoft.Policies.Windows" prefix="windows"/>\n' | |
| 100 ' </policyNamespaces>\n' | |
| 101 ' <resources minRequiredRevision="1.0"/>\n' | |
| 102 ' <supportedOn>\n' | |
| 103 ' <definitions>\n' | |
| 104 ' <definition displayName="' | |
| 105 '$(string.SUPPORTED_TESTOS)" name="SUPPORTED_TESTOS"/>\n' | |
| 106 ' </definitions>\n' | |
| 107 ' </supportedOn>\n' | |
| 108 ' <categories>\n' | |
| 109 ' <category displayName="$(string.test_category)"' | |
| 110 ' name="test_category"/>\n' | |
| 111 ' <category displayName="$(string.test_recommended_category)"' | |
| 112 ' name="test_recommended_category"/>\n' | |
| 113 ' </categories>\n' | |
| 114 ' <policies/>\n' | |
| 115 '</policyDefinitions>') | |
| 116 self.AssertXMLEquals(output, expected_output) | |
| 117 | |
| 118 def testEmptyPolicyGroup(self): | |
| 119 empty_policy_group = { | |
| 120 'name': 'PolicyGroup', | |
| 121 'policies': [] | |
| 122 } | |
| 123 # Initialize writer to write a policy group. | |
| 124 self.writer.BeginTemplate() | |
| 125 # Write policy group | |
| 126 self.writer.BeginPolicyGroup(empty_policy_group) | |
| 127 self.writer.EndPolicyGroup() | |
| 128 | |
| 129 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 130 expected_output = '' | |
| 131 self.AssertXMLEquals(output, expected_output) | |
| 132 | |
| 133 output = self.GetXMLOfChildren( | |
| 134 self._GetCategoriesElement(self.writer._doc)) | |
| 135 expected_output = ( | |
| 136 '<category displayName="$(string.test_category)"' | |
| 137 ' name="test_category"/>\n' | |
| 138 '<category displayName="$(string.test_recommended_category)"' | |
| 139 ' name="test_recommended_category"/>\n' | |
| 140 '<category displayName="$(string.PolicyGroup_group)"' | |
| 141 ' name="PolicyGroup">\n' | |
| 142 ' <parentCategory ref="test_category"/>\n' | |
| 143 '</category>') | |
| 144 | |
| 145 self.AssertXMLEquals(output, expected_output) | |
| 146 | |
| 147 def testPolicyGroup(self): | |
| 148 empty_policy_group = { | |
| 149 'name': 'PolicyGroup', | |
| 150 'policies': [ | |
| 151 {'name': 'PolicyStub2', | |
| 152 'type': 'main'}, | |
| 153 {'name': 'PolicyStub1', | |
| 154 'type': 'main'}, | |
| 155 ] | |
| 156 } | |
| 157 # Initialize writer to write a policy group. | |
| 158 self.writer.BeginTemplate() | |
| 159 # Write policy group | |
| 160 self.writer.BeginPolicyGroup(empty_policy_group) | |
| 161 self.writer.EndPolicyGroup() | |
| 162 | |
| 163 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 164 expected_output = '' | |
| 165 self.AssertXMLEquals(output, expected_output) | |
| 166 | |
| 167 output = self.GetXMLOfChildren( | |
| 168 self._GetCategoriesElement(self.writer._doc)) | |
| 169 expected_output = ( | |
| 170 '<category displayName="$(string.test_category)"' | |
| 171 ' name="test_category"/>\n' | |
| 172 '<category displayName="$(string.test_recommended_category)"' | |
| 173 ' name="test_recommended_category"/>\n' | |
| 174 '<category displayName="$(string.PolicyGroup_group)"' | |
| 175 ' name="PolicyGroup">\n' | |
| 176 ' <parentCategory ref="test_category"/>\n' | |
| 177 '</category>') | |
| 178 self.AssertXMLEquals(output, expected_output) | |
| 179 | |
| 180 | |
| 181 def _initWriterForPolicy(self, writer, policy): | |
| 182 '''Initializes the writer to write the given policy next. | |
| 183 ''' | |
| 184 policy_group = { | |
| 185 'name': 'PolicyGroup', | |
| 186 'policies': [policy] | |
| 187 } | |
| 188 writer.BeginTemplate() | |
| 189 writer.BeginPolicyGroup(policy_group) | |
| 190 | |
| 191 def testMainPolicy(self): | |
| 192 main_policy = { | |
| 193 'name': 'DummyMainPolicy', | |
| 194 'type': 'main', | |
| 195 } | |
| 196 | |
| 197 self._initWriterForPolicy(self.writer, main_policy) | |
| 198 | |
| 199 self.writer.WritePolicy(main_policy) | |
| 200 | |
| 201 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 202 expected_output = ( | |
| 203 '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"' | |
| 204 ' explainText="$(string.DummyMainPolicy_Explain)"' | |
| 205 ' key="Software\\Policies\\Test" name="DummyMainPolicy"' | |
| 206 ' presentation="$(presentation.DummyMainPolicy)"' | |
| 207 ' valueName="DummyMainPolicy">\n' | |
| 208 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 209 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 210 ' <enabledValue>\n' | |
| 211 ' <decimal value="1"/>\n' | |
| 212 ' </enabledValue>\n' | |
| 213 ' <disabledValue>\n' | |
| 214 ' <decimal value="0"/>\n' | |
| 215 ' </disabledValue>\n' | |
| 216 '</policy>') | |
| 217 | |
| 218 self.AssertXMLEquals(output, expected_output) | |
| 219 | |
| 220 def testRecommendedPolicy(self): | |
| 221 main_policy = { | |
| 222 'name': 'DummyMainPolicy', | |
| 223 'type': 'main', | |
| 224 } | |
| 225 | |
| 226 policy_group = { | |
| 227 'name': 'PolicyGroup', | |
| 228 'policies': [main_policy], | |
| 229 } | |
| 230 self.writer.BeginTemplate() | |
| 231 self.writer.BeginRecommendedPolicyGroup(policy_group) | |
| 232 | |
| 233 self.writer.WriteRecommendedPolicy(main_policy) | |
| 234 | |
| 235 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 236 expected_output = ( | |
| 237 '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"' | |
| 238 ' explainText="$(string.DummyMainPolicy_Explain)"' | |
| 239 ' key="Software\\Policies\\Test\\Recommended"' | |
| 240 ' name="DummyMainPolicy_recommended"' | |
| 241 ' presentation="$(presentation.DummyMainPolicy)"' | |
| 242 ' valueName="DummyMainPolicy">\n' | |
| 243 ' <parentCategory ref="PolicyGroup_recommended"/>\n' | |
| 244 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 245 ' <enabledValue>\n' | |
| 246 ' <decimal value="1"/>\n' | |
| 247 ' </enabledValue>\n' | |
| 248 ' <disabledValue>\n' | |
| 249 ' <decimal value="0"/>\n' | |
| 250 ' </disabledValue>\n' | |
| 251 '</policy>') | |
| 252 | |
| 253 self.AssertXMLEquals(output, expected_output) | |
| 254 | |
| 255 def testRecommendedOnlyPolicy(self): | |
| 256 main_policy = { | |
| 257 'name': 'DummyMainPolicy', | |
| 258 'type': 'main', | |
| 259 'features': { | |
| 260 'can_be_recommended': True, | |
| 261 'can_be_mandatory': False, | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 policy_group = { | |
| 266 'name': 'PolicyGroup', | |
| 267 'policies': [main_policy], | |
| 268 } | |
| 269 self.writer.BeginTemplate() | |
| 270 self.writer.BeginRecommendedPolicyGroup(policy_group) | |
| 271 | |
| 272 self.writer.WritePolicy(main_policy) | |
| 273 self.writer.WriteRecommendedPolicy(main_policy) | |
| 274 | |
| 275 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 276 expected_output = ( | |
| 277 '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"' | |
| 278 ' explainText="$(string.DummyMainPolicy_Explain)"' | |
| 279 ' key="Software\\Policies\\Test\\Recommended"' | |
| 280 ' name="DummyMainPolicy_recommended"' | |
| 281 ' presentation="$(presentation.DummyMainPolicy)"' | |
| 282 ' valueName="DummyMainPolicy">\n' | |
| 283 ' <parentCategory ref="PolicyGroup_recommended"/>\n' | |
| 284 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 285 ' <enabledValue>\n' | |
| 286 ' <decimal value="1"/>\n' | |
| 287 ' </enabledValue>\n' | |
| 288 ' <disabledValue>\n' | |
| 289 ' <decimal value="0"/>\n' | |
| 290 ' </disabledValue>\n' | |
| 291 '</policy>') | |
| 292 | |
| 293 self.AssertXMLEquals(output, expected_output) | |
| 294 | |
| 295 def testStringPolicy(self): | |
| 296 string_policy = { | |
| 297 'name': 'SampleStringPolicy', | |
| 298 'type': 'string', | |
| 299 } | |
| 300 self._initWriterForPolicy(self.writer, string_policy) | |
| 301 | |
| 302 self.writer.WritePolicy(string_policy) | |
| 303 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 304 expected_output = ( | |
| 305 '<policy class="TestClass" displayName="$(string.SampleStringPolicy)"' | |
| 306 ' explainText="$(string.SampleStringPolicy_Explain)"' | |
| 307 ' key="Software\\Policies\\Test" name="SampleStringPolicy"' | |
| 308 ' presentation="$(presentation.SampleStringPolicy)">\n' | |
| 309 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 310 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 311 ' <elements>\n' | |
| 312 ' <text id="SampleStringPolicy" maxLength="1000000"' | |
| 313 ' valueName="SampleStringPolicy"/>\n' | |
| 314 ' </elements>\n' | |
| 315 '</policy>') | |
| 316 self.AssertXMLEquals(output, expected_output) | |
| 317 | |
| 318 def testIntPolicy(self): | |
| 319 int_policy = { | |
| 320 'name': 'SampleIntPolicy', | |
| 321 'type': 'int', | |
| 322 } | |
| 323 self._initWriterForPolicy(self.writer, int_policy) | |
| 324 | |
| 325 self.writer.WritePolicy(int_policy) | |
| 326 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 327 expected_output = ( | |
| 328 '<policy class="TestClass" displayName="$(string.SampleIntPolicy)"' | |
| 329 ' explainText="$(string.SampleIntPolicy_Explain)"' | |
| 330 ' key="Software\\Policies\\Test" name="SampleIntPolicy"' | |
| 331 ' presentation="$(presentation.SampleIntPolicy)">\n' | |
| 332 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 333 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 334 ' <elements>\n' | |
| 335 ' <decimal id="SampleIntPolicy" maxValue="2000000000" ' | |
| 336 'valueName="SampleIntPolicy"/>\n' | |
| 337 ' </elements>\n' | |
| 338 '</policy>') | |
| 339 self.AssertXMLEquals(output, expected_output) | |
| 340 | |
| 341 def testIntEnumPolicy(self): | |
| 342 enum_policy = { | |
| 343 'name': 'SampleEnumPolicy', | |
| 344 'type': 'int-enum', | |
| 345 'items': [ | |
| 346 {'name': 'item_1', 'value': 0}, | |
| 347 {'name': 'item_2', 'value': 1}, | |
| 348 ] | |
| 349 } | |
| 350 | |
| 351 self._initWriterForPolicy(self.writer, enum_policy) | |
| 352 self.writer.WritePolicy(enum_policy) | |
| 353 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 354 expected_output = ( | |
| 355 '<policy class="TestClass" displayName="$(string.SampleEnumPolicy)"' | |
| 356 ' explainText="$(string.SampleEnumPolicy_Explain)"' | |
| 357 ' key="Software\\Policies\\Test" name="SampleEnumPolicy"' | |
| 358 ' presentation="$(presentation.SampleEnumPolicy)">\n' | |
| 359 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 360 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 361 ' <elements>\n' | |
| 362 ' <enum id="SampleEnumPolicy" valueName="SampleEnumPolicy">\n' | |
| 363 ' <item displayName="$(string.item_1)">\n' | |
| 364 ' <value>\n' | |
| 365 ' <decimal value="0"/>\n' | |
| 366 ' </value>\n' | |
| 367 ' </item>\n' | |
| 368 ' <item displayName="$(string.item_2)">\n' | |
| 369 ' <value>\n' | |
| 370 ' <decimal value="1"/>\n' | |
| 371 ' </value>\n' | |
| 372 ' </item>\n' | |
| 373 ' </enum>\n' | |
| 374 ' </elements>\n' | |
| 375 '</policy>') | |
| 376 self.AssertXMLEquals(output, expected_output) | |
| 377 | |
| 378 def testStringEnumPolicy(self): | |
| 379 enum_policy = { | |
| 380 'name': 'SampleEnumPolicy', | |
| 381 'type': 'string-enum', | |
| 382 'items': [ | |
| 383 {'name': 'item_1', 'value': 'one'}, | |
| 384 {'name': 'item_2', 'value': 'two'}, | |
| 385 ] | |
| 386 } | |
| 387 | |
| 388 # This test is different than the others because it also tests that space | |
| 389 # usage inside <string> nodes is correct. | |
| 390 dom_impl = minidom.getDOMImplementation('') | |
| 391 self.writer._doc = dom_impl.createDocument(None, 'policyDefinitions', None) | |
| 392 self.writer._active_policies_elem = self.writer._doc.documentElement | |
| 393 self.writer._active_mandatory_policy_group_name = 'PolicyGroup' | |
| 394 self.writer.WritePolicy(enum_policy) | |
| 395 output = self.writer.GetTemplateText() | |
| 396 expected_output = ( | |
| 397 '<?xml version="1.0" ?>\n' | |
| 398 '<policyDefinitions>\n' | |
| 399 ' <policy class="TestClass" displayName="$(string.SampleEnumPolicy)"' | |
| 400 ' explainText="$(string.SampleEnumPolicy_Explain)"' | |
| 401 ' key="Software\\Policies\\Test" name="SampleEnumPolicy"' | |
| 402 ' presentation="$(presentation.SampleEnumPolicy)">\n' | |
| 403 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 404 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 405 ' <elements>\n' | |
| 406 ' <enum id="SampleEnumPolicy" valueName="SampleEnumPolicy">\n' | |
| 407 ' <item displayName="$(string.item_1)">\n' | |
| 408 ' <value>\n' | |
| 409 ' <string>one</string>\n' | |
| 410 ' </value>\n' | |
| 411 ' </item>\n' | |
| 412 ' <item displayName="$(string.item_2)">\n' | |
| 413 ' <value>\n' | |
| 414 ' <string>two</string>\n' | |
| 415 ' </value>\n' | |
| 416 ' </item>\n' | |
| 417 ' </enum>\n' | |
| 418 ' </elements>\n' | |
| 419 ' </policy>\n' | |
| 420 '</policyDefinitions>') | |
| 421 self.AssertXMLEquals(output, expected_output) | |
| 422 | |
| 423 def testListPolicy(self): | |
| 424 list_policy = { | |
| 425 'name': 'SampleListPolicy', | |
| 426 'type': 'list', | |
| 427 } | |
| 428 self._initWriterForPolicy(self.writer, list_policy) | |
| 429 self.writer.WritePolicy(list_policy) | |
| 430 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 431 expected_output = ( | |
| 432 '<policy class="TestClass" displayName="$(string.SampleListPolicy)"' | |
| 433 ' explainText="$(string.SampleListPolicy_Explain)"' | |
| 434 ' key="Software\\Policies\\Test" name="SampleListPolicy"' | |
| 435 ' presentation="$(presentation.SampleListPolicy)">\n' | |
| 436 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 437 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 438 ' <elements>\n' | |
| 439 ' <list id="SampleListPolicyDesc"' | |
| 440 ' key="Software\Policies\Test\SampleListPolicy" valuePrefix=""/>\n' | |
| 441 ' </elements>\n' | |
| 442 '</policy>') | |
| 443 | |
| 444 self.AssertXMLEquals(output, expected_output) | |
| 445 | |
| 446 def testStringEnumListPolicy(self): | |
| 447 list_policy = { | |
| 448 'name': 'SampleListPolicy', | |
| 449 'type': 'string-enum-list', | |
| 450 'items': [ | |
| 451 {'name': 'item_1', 'value': 'one'}, | |
| 452 {'name': 'item_2', 'value': 'two'}, | |
| 453 ] | |
| 454 } | |
| 455 self._initWriterForPolicy(self.writer, list_policy) | |
| 456 self.writer.WritePolicy(list_policy) | |
| 457 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 458 expected_output = ( | |
| 459 '<policy class="TestClass" displayName="$(string.SampleListPolicy)"' | |
| 460 ' explainText="$(string.SampleListPolicy_Explain)"' | |
| 461 ' key="Software\\Policies\\Test" name="SampleListPolicy"' | |
| 462 ' presentation="$(presentation.SampleListPolicy)">\n' | |
| 463 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 464 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 465 ' <elements>\n' | |
| 466 ' <list id="SampleListPolicyDesc"' | |
| 467 ' key="Software\Policies\Test\SampleListPolicy" valuePrefix=""/>\n' | |
| 468 ' </elements>\n' | |
| 469 '</policy>') | |
| 470 | |
| 471 self.AssertXMLEquals(output, expected_output) | |
| 472 | |
| 473 def testDictionaryPolicy(self): | |
| 474 dict_policy = { | |
| 475 'name': 'SampleDictionaryPolicy', | |
| 476 'type': 'dict', | |
| 477 } | |
| 478 self._initWriterForPolicy(self.writer, dict_policy) | |
| 479 | |
| 480 self.writer.WritePolicy(dict_policy) | |
| 481 output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc)) | |
| 482 expected_output = ( | |
| 483 '<policy class="TestClass" displayName="$(string.' | |
| 484 'SampleDictionaryPolicy)"' | |
| 485 ' explainText="$(string.SampleDictionaryPolicy_Explain)"' | |
| 486 ' key="Software\\Policies\\Test" name="SampleDictionaryPolicy"' | |
| 487 ' presentation="$(presentation.SampleDictionaryPolicy)">\n' | |
| 488 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 489 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 490 ' <elements>\n' | |
| 491 ' <text id="SampleDictionaryPolicy" maxLength="1000000"' | |
| 492 ' valueName="SampleDictionaryPolicy"/>\n' | |
| 493 ' </elements>\n' | |
| 494 '</policy>') | |
| 495 self.AssertXMLEquals(output, expected_output) | |
| 496 | |
| 497 def testPlatform(self): | |
| 498 # Test that the writer correctly chooses policies of platform Windows. | |
| 499 self.assertTrue(self.writer.IsPolicySupported({ | |
| 500 'supported_on': [ | |
| 501 {'platforms': ['win', 'zzz']}, {'platforms': ['aaa']} | |
| 502 ] | |
| 503 })) | |
| 504 self.assertFalse(self.writer.IsPolicySupported({ | |
| 505 'supported_on': [ | |
| 506 {'platforms': ['mac', 'linux']}, {'platforms': ['aaa']} | |
| 507 ] | |
| 508 })) | |
| 509 | |
| 510 def testStringEncodings(self): | |
| 511 enum_policy_a = { | |
| 512 'name': 'SampleEnumPolicy.A', | |
| 513 'type': 'string-enum', | |
| 514 'items': [ | |
| 515 {'name': 'tls1.2', 'value': 'tls1.2'} | |
| 516 ] | |
| 517 } | |
| 518 enum_policy_b = { | |
| 519 'name': 'SampleEnumPolicy.B', | |
| 520 'type': 'string-enum', | |
| 521 'items': [ | |
| 522 {'name': 'tls1.2', 'value': 'tls1.2'} | |
| 523 ] | |
| 524 } | |
| 525 | |
| 526 dom_impl = minidom.getDOMImplementation('') | |
| 527 self.writer._doc = dom_impl.createDocument(None, 'policyDefinitions', None) | |
| 528 self.writer._active_policies_elem = self.writer._doc.documentElement | |
| 529 self.writer._active_mandatory_policy_group_name = 'PolicyGroup' | |
| 530 self.writer.WritePolicy(enum_policy_a) | |
| 531 self.writer.WritePolicy(enum_policy_b) | |
| 532 output = self.writer.GetTemplateText() | |
| 533 expected_output = ( | |
| 534 '<?xml version="1.0" ?>\n' | |
| 535 '<policyDefinitions>\n' | |
| 536 ' <policy class="TestClass" displayName="$(string.SampleEnumPolicy_A)"' | |
| 537 ' explainText="$(string.SampleEnumPolicy_A_Explain)"' | |
| 538 ' key="Software\\Policies\\Test" name="SampleEnumPolicy.A"' | |
| 539 ' presentation="$(presentation.SampleEnumPolicy.A)">\n' | |
| 540 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 541 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 542 ' <elements>\n' | |
| 543 ' <enum id="SampleEnumPolicy.A" valueName="SampleEnumPolicy.A">\n' | |
| 544 ' <item displayName="$(string.tls1_2)">\n' | |
| 545 ' <value>\n' | |
| 546 ' <string>tls1.2</string>\n' | |
| 547 ' </value>\n' | |
| 548 ' </item>\n' | |
| 549 ' </enum>\n' | |
| 550 ' </elements>\n' | |
| 551 ' </policy>\n' | |
| 552 ' <policy class="TestClass" displayName="$(string.SampleEnumPolicy_B)"' | |
| 553 ' explainText="$(string.SampleEnumPolicy_B_Explain)"' | |
| 554 ' key="Software\\Policies\\Test" name="SampleEnumPolicy.B"' | |
| 555 ' presentation="$(presentation.SampleEnumPolicy.B)">\n' | |
| 556 ' <parentCategory ref="PolicyGroup"/>\n' | |
| 557 ' <supportedOn ref="SUPPORTED_TESTOS"/>\n' | |
| 558 ' <elements>\n' | |
| 559 ' <enum id="SampleEnumPolicy.B" valueName="SampleEnumPolicy.B">\n' | |
| 560 ' <item displayName="$(string.tls1_2)">\n' | |
| 561 ' <value>\n' | |
| 562 ' <string>tls1.2</string>\n' | |
| 563 ' </value>\n' | |
| 564 ' </item>\n' | |
| 565 ' </enum>\n' | |
| 566 ' </elements>\n' | |
| 567 ' </policy>\n' | |
| 568 '</policyDefinitions>') | |
| 569 self.AssertXMLEquals(output, expected_output) | |
| 570 | |
| 571 | |
| 572 if __name__ == '__main__': | |
| 573 unittest.main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1442863002:
Remove contents of grit's SVN repository. (Closed)
Base URL: http://grit-i18n.googlecode.com/svn/trunk/