src/tools/grit/grit/format/policy_templates/writers/admx_writer_unittest.py

   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     }
  42     self.writer = admx_writer.GetWriter(config)
  43     self.writer.Init()
  44
  45   def _GetPoliciesElement(self, doc):
  46     node_list = doc.getElementsByTagName('policies')
  47     self.assertTrue(node_list.length == 1)
  48     return node_list.item(0)
  49
  50   def _GetCategoriesElement(self, doc):
  51     node_list = doc.getElementsByTagName('categories')
  52     self.assertTrue(node_list.length == 1)
  53     return node_list.item(0)
  54
  55   def testEmpty(self):
  56     self.writer.BeginTemplate()
  57     self.writer.EndTemplate()
  58
  59     output = self.writer.GetTemplateText()
  60     expected_output = (
  61         '<?xml version="1.0" ?>\n'
  62         '<policyDefinitions revision="1.0" schemaVersion="1.0">\n'
  63         '  <policyNamespaces>\n'
  64         '    <target namespace="ADMXWriter.Test.Namespace"'
  65         ' prefix="test_prefix"/>\n'
  66         '    <using namespace="Microsoft.Policies.Windows" prefix="windows"/>\n'
  67         '  </policyNamespaces>\n'
  68         '  <resources minRequiredRevision="1.0"/>\n'
  69         '  <supportedOn>\n'
  70         '    <definitions>\n'
  71         '      <definition displayName="'
  72         '$(string.SUPPORTED_TESTOS)" name="SUPPORTED_TESTOS"/>\n'
  73         '    </definitions>\n'
  74         '  </supportedOn>\n'
  75         '  <categories>\n'
  76         '    <category displayName="$(string.test_category)"'
  77         ' name="test_category"/>\n'
  78         '    <category displayName="$(string.test_recommended_category)"'
  79         ' name="test_recommended_category"/>\n'
  80         '  </categories>\n'
  81         '  <policies/>\n'
  82         '</policyDefinitions>')
  83     self.AssertXMLEquals(output, expected_output)
  84
  85   def testEmptyPolicyGroup(self):
  86     empty_policy_group = {
  87       'name': 'PolicyGroup',
  88       'policies': []
  89     }
  90     # Initialize writer to write a policy group.
  91     self.writer.BeginTemplate()
  92     # Write policy group
  93     self.writer.BeginPolicyGroup(empty_policy_group)
  94     self.writer.EndPolicyGroup()
  95
  96     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
  97     expected_output = ''
  98     self.AssertXMLEquals(output, expected_output)
  99
 100     output = self.GetXMLOfChildren(
 101         self._GetCategoriesElement(self.writer._doc))
 102     expected_output = (
 103         '<category displayName="$(string.test_category)"'
 104         ' name="test_category"/>\n'
 105         '<category displayName="$(string.test_recommended_category)"'
 106         ' name="test_recommended_category"/>\n'
 107         '<category displayName="$(string.PolicyGroup_group)"'
 108         ' name="PolicyGroup">\n'
 109         '  <parentCategory ref="test_category"/>\n'
 110         '</category>')
 111
 112     self.AssertXMLEquals(output, expected_output)
 113
 114   def testPolicyGroup(self):
 115     empty_policy_group = {
 116       'name': 'PolicyGroup',
 117       'policies': [
 118           {'name': 'PolicyStub2',
 119           'type': 'main'},
 120           {'name': 'PolicyStub1',
 121           'type': 'main'},
 122       ]
 123     }
 124     # Initialize writer to write a policy group.
 125     self.writer.BeginTemplate()
 126     # Write policy group
 127     self.writer.BeginPolicyGroup(empty_policy_group)
 128     self.writer.EndPolicyGroup()
 129
 130     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 131     expected_output = ''
 132     self.AssertXMLEquals(output, expected_output)
 133
 134     output = self.GetXMLOfChildren(
 135         self._GetCategoriesElement(self.writer._doc))
 136     expected_output = (
 137         '<category displayName="$(string.test_category)"'
 138         ' name="test_category"/>\n'
 139         '<category displayName="$(string.test_recommended_category)"'
 140         ' name="test_recommended_category"/>\n'
 141         '<category displayName="$(string.PolicyGroup_group)"'
 142         ' name="PolicyGroup">\n'
 143         '  <parentCategory ref="test_category"/>\n'
 144         '</category>')
 145     self.AssertXMLEquals(output, expected_output)
 146
 147
 148   def _initWriterForPolicy(self, writer, policy):
 149     '''Initializes the writer to write the given policy next.
 150     '''
 151     policy_group = {
 152       'name': 'PolicyGroup',
 153       'policies': [policy]
 154     }
 155     writer.BeginTemplate()
 156     writer.BeginPolicyGroup(policy_group)
 157
 158   def testMainPolicy(self):
 159     main_policy = {
 160       'name': 'DummyMainPolicy',
 161       'type': 'main',
 162     }
 163
 164     self._initWriterForPolicy(self.writer, main_policy)
 165
 166     self.writer.WritePolicy(main_policy)
 167
 168     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 169     expected_output = (
 170         '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"'
 171         ' explainText="$(string.DummyMainPolicy_Explain)"'
 172         ' key="Software\\Policies\\Test" name="DummyMainPolicy"'
 173         ' presentation="$(presentation.DummyMainPolicy)"'
 174         ' valueName="DummyMainPolicy">\n'
 175         '  <parentCategory ref="PolicyGroup"/>\n'
 176         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 177         '  <enabledValue>\n'
 178         '    <decimal value="1"/>\n'
 179         '  </enabledValue>\n'
 180         '  <disabledValue>\n'
 181         '    <decimal value="0"/>\n'
 182         '  </disabledValue>\n'
 183         '</policy>')
 184
 185     self.AssertXMLEquals(output, expected_output)
 186
 187   def testRecommendedPolicy(self):
 188     main_policy = {
 189       'name': 'DummyMainPolicy',
 190       'type': 'main',
 191     }
 192
 193     policy_group = {
 194       'name': 'PolicyGroup',
 195       'policies': [main_policy],
 196     }
 197     self.writer.BeginTemplate()
 198     self.writer.BeginRecommendedPolicyGroup(policy_group)
 199
 200     self.writer.WriteRecommendedPolicy(main_policy)
 201
 202     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 203     expected_output = (
 204         '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"'
 205         ' explainText="$(string.DummyMainPolicy_Explain)"'
 206         ' key="Software\\Policies\\Test\\Recommended"'
 207         ' name="DummyMainPolicy_recommended"'
 208         ' presentation="$(presentation.DummyMainPolicy)"'
 209         ' valueName="DummyMainPolicy">\n'
 210         '  <parentCategory ref="PolicyGroup_recommended"/>\n'
 211         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 212         '  <enabledValue>\n'
 213         '    <decimal value="1"/>\n'
 214         '  </enabledValue>\n'
 215         '  <disabledValue>\n'
 216         '    <decimal value="0"/>\n'
 217         '  </disabledValue>\n'
 218         '</policy>')
 219
 220     self.AssertXMLEquals(output, expected_output)
 221
 222   def testRecommendedOnlyPolicy(self):
 223     main_policy = {
 224       'name': 'DummyMainPolicy',
 225       'type': 'main',
 226       'features': {
 227         'can_be_recommended': True,
 228         'can_be_mandatory': False,
 229       }
 230     }
 231
 232     policy_group = {
 233       'name': 'PolicyGroup',
 234       'policies': [main_policy],
 235     }
 236     self.writer.BeginTemplate()
 237     self.writer.BeginRecommendedPolicyGroup(policy_group)
 238
 239     self.writer.WritePolicy(main_policy)
 240     self.writer.WriteRecommendedPolicy(main_policy)
 241
 242     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 243     expected_output = (
 244         '<policy class="TestClass" displayName="$(string.DummyMainPolicy)"'
 245         ' explainText="$(string.DummyMainPolicy_Explain)"'
 246         ' key="Software\\Policies\\Test\\Recommended"'
 247         ' name="DummyMainPolicy_recommended"'
 248         ' presentation="$(presentation.DummyMainPolicy)"'
 249         ' valueName="DummyMainPolicy">\n'
 250         '  <parentCategory ref="PolicyGroup_recommended"/>\n'
 251         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 252         '  <enabledValue>\n'
 253         '    <decimal value="1"/>\n'
 254         '  </enabledValue>\n'
 255         '  <disabledValue>\n'
 256         '    <decimal value="0"/>\n'
 257         '  </disabledValue>\n'
 258         '</policy>')
 259
 260     self.AssertXMLEquals(output, expected_output)
 261
 262   def testStringPolicy(self):
 263     string_policy = {
 264       'name': 'SampleStringPolicy',
 265       'type': 'string',
 266     }
 267     self._initWriterForPolicy(self.writer, string_policy)
 268
 269     self.writer.WritePolicy(string_policy)
 270     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 271     expected_output = (
 272         '<policy class="TestClass" displayName="$(string.SampleStringPolicy)"'
 273         ' explainText="$(string.SampleStringPolicy_Explain)"'
 274         ' key="Software\\Policies\\Test" name="SampleStringPolicy"'
 275         ' presentation="$(presentation.SampleStringPolicy)">\n'
 276         '  <parentCategory ref="PolicyGroup"/>\n'
 277         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 278         '  <elements>\n'
 279         '    <text id="SampleStringPolicy" valueName="SampleStringPolicy"/>\n'
 280         '  </elements>\n'
 281         '</policy>')
 282     self.AssertXMLEquals(output, expected_output)
 283
 284   def testIntPolicy(self):
 285     int_policy = {
 286       'name': 'SampleIntPolicy',
 287       'type': 'int',
 288     }
 289     self._initWriterForPolicy(self.writer, int_policy)
 290
 291     self.writer.WritePolicy(int_policy)
 292     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 293     expected_output = (
 294         '<policy class="TestClass" displayName="$(string.SampleIntPolicy)"'
 295         ' explainText="$(string.SampleIntPolicy_Explain)"'
 296         ' key="Software\\Policies\\Test" name="SampleIntPolicy"'
 297         ' presentation="$(presentation.SampleIntPolicy)">\n'
 298         '  <parentCategory ref="PolicyGroup"/>\n'
 299         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 300         '  <elements>\n'
 301         '    <decimal id="SampleIntPolicy" maxValue="2000000000" '
 302         'valueName="SampleIntPolicy"/>\n'
 303         '  </elements>\n'
 304         '</policy>')
 305     self.AssertXMLEquals(output, expected_output)
 306
 307   def testIntEnumPolicy(self):
 308     enum_policy = {
 309       'name': 'SampleEnumPolicy',
 310       'type': 'int-enum',
 311         'items': [
 312           {'name': 'item_1', 'value': 0},
 313           {'name': 'item_2', 'value': 1},
 314         ]
 315     }
 316
 317     self._initWriterForPolicy(self.writer, enum_policy)
 318     self.writer.WritePolicy(enum_policy)
 319     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 320     expected_output = (
 321         '<policy class="TestClass" displayName="$(string.SampleEnumPolicy)"'
 322         ' explainText="$(string.SampleEnumPolicy_Explain)"'
 323         ' key="Software\\Policies\\Test" name="SampleEnumPolicy"'
 324         ' presentation="$(presentation.SampleEnumPolicy)">\n'
 325         '  <parentCategory ref="PolicyGroup"/>\n'
 326         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 327         '  <elements>\n'
 328         '    <enum id="SampleEnumPolicy" valueName="SampleEnumPolicy">\n'
 329         '      <item displayName="$(string.item_1)">\n'
 330         '        <value>\n'
 331         '          <decimal value="0"/>\n'
 332         '        </value>\n'
 333         '      </item>\n'
 334         '      <item displayName="$(string.item_2)">\n'
 335         '        <value>\n'
 336         '          <decimal value="1"/>\n'
 337         '        </value>\n'
 338         '      </item>\n'
 339         '    </enum>\n'
 340         '  </elements>\n'
 341         '</policy>')
 342     self.AssertXMLEquals(output, expected_output)
 343
 344   def testStringEnumPolicy(self):
 345     enum_policy = {
 346       'name': 'SampleEnumPolicy',
 347       'type': 'string-enum',
 348         'items': [
 349           {'name': 'item_1', 'value': 'one'},
 350           {'name': 'item_2', 'value': 'two'},
 351         ]
 352     }
 353
 354     # This test is different than the others because it also tests that space
 355     # usage inside <string> nodes is correct.
 356     dom_impl = minidom.getDOMImplementation('')
 357     self.writer._doc = dom_impl.createDocument(None, 'policyDefinitions', None)
 358     self.writer._active_policies_elem = self.writer._doc.documentElement
 359     self.writer._active_mandatory_policy_group_name = 'PolicyGroup'
 360     self.writer.WritePolicy(enum_policy)
 361     output = self.writer.GetTemplateText()
 362     expected_output = (
 363         '<?xml version="1.0" ?>\n'
 364         '<policyDefinitions>\n'
 365         '  <policy class="TestClass" displayName="$(string.SampleEnumPolicy)"'
 366           ' explainText="$(string.SampleEnumPolicy_Explain)"'
 367           ' key="Software\\Policies\\Test" name="SampleEnumPolicy"'
 368           ' presentation="$(presentation.SampleEnumPolicy)">\n'
 369         '    <parentCategory ref="PolicyGroup"/>\n'
 370         '    <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 371         '    <elements>\n'
 372         '      <enum id="SampleEnumPolicy" valueName="SampleEnumPolicy">\n'
 373         '        <item displayName="$(string.item_1)">\n'
 374         '          <value>\n'
 375         '            <string>one</string>\n'
 376         '          </value>\n'
 377         '        </item>\n'
 378         '        <item displayName="$(string.item_2)">\n'
 379         '          <value>\n'
 380         '            <string>two</string>\n'
 381         '          </value>\n'
 382         '        </item>\n'
 383         '      </enum>\n'
 384         '    </elements>\n'
 385         '  </policy>\n'
 386         '</policyDefinitions>')
 387     self.AssertXMLEquals(output, expected_output)
 388
 389   def testListPolicy(self):
 390     list_policy = {
 391       'name': 'SampleListPolicy',
 392       'type': 'list',
 393     }
 394     self._initWriterForPolicy(self.writer, list_policy)
 395     self.writer.WritePolicy(list_policy)
 396     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 397     expected_output = (
 398         '<policy class="TestClass" displayName="$(string.SampleListPolicy)"'
 399         ' explainText="$(string.SampleListPolicy_Explain)"'
 400         ' key="Software\\Policies\\Test" name="SampleListPolicy"'
 401         ' presentation="$(presentation.SampleListPolicy)">\n'
 402         '  <parentCategory ref="PolicyGroup"/>\n'
 403         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 404         '  <elements>\n'
 405         '    <list id="SampleListPolicyDesc"'
 406         ' key="Software\Policies\Test\SampleListPolicy" valuePrefix=""/>\n'
 407         '  </elements>\n'
 408         '</policy>')
 409
 410     self.AssertXMLEquals(output, expected_output)
 411
 412   def testStringEnumListPolicy(self):
 413     list_policy = {
 414       'name': 'SampleListPolicy',
 415       'type': 'string-enum-list',
 416       'items': [
 417         {'name': 'item_1', 'value': 'one'},
 418         {'name': 'item_2', 'value': 'two'},
 419       ]
 420     }
 421     self._initWriterForPolicy(self.writer, list_policy)
 422     self.writer.WritePolicy(list_policy)
 423     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 424     expected_output = (
 425         '<policy class="TestClass" displayName="$(string.SampleListPolicy)"'
 426         ' explainText="$(string.SampleListPolicy_Explain)"'
 427         ' key="Software\\Policies\\Test" name="SampleListPolicy"'
 428         ' presentation="$(presentation.SampleListPolicy)">\n'
 429         '  <parentCategory ref="PolicyGroup"/>\n'
 430         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 431         '  <elements>\n'
 432         '    <list id="SampleListPolicyDesc"'
 433         ' key="Software\Policies\Test\SampleListPolicy" valuePrefix=""/>\n'
 434         '  </elements>\n'
 435         '</policy>')
 436
 437     self.AssertXMLEquals(output, expected_output)
 438
 439   def testDictionaryPolicy(self):
 440     dict_policy = {
 441       'name': 'SampleDictionaryPolicy',
 442       'type': 'dict',
 443     }
 444     self._initWriterForPolicy(self.writer, dict_policy)
 445
 446     self.writer.WritePolicy(dict_policy)
 447     output = self.GetXMLOfChildren(self._GetPoliciesElement(self.writer._doc))
 448     expected_output = (
 449         '<policy class="TestClass" displayName="$(string.'
 450             'SampleDictionaryPolicy)"'
 451         ' explainText="$(string.SampleDictionaryPolicy_Explain)"'
 452         ' key="Software\\Policies\\Test" name="SampleDictionaryPolicy"'
 453         ' presentation="$(presentation.SampleDictionaryPolicy)">\n'
 454         '  <parentCategory ref="PolicyGroup"/>\n'
 455         '  <supportedOn ref="SUPPORTED_TESTOS"/>\n'
 456         '  <elements>\n'
 457         '    <text id="SampleDictionaryPolicy" '
 458             'valueName="SampleDictionaryPolicy"/>\n'
 459         '  </elements>\n'
 460         '</policy>')
 461     self.AssertXMLEquals(output, expected_output)
 462
 463   def testPlatform(self):
 464     # Test that the writer correctly chooses policies of platform Windows.
 465     self.assertTrue(self.writer.IsPolicySupported({
 466       'supported_on': [
 467         {'platforms': ['win', 'zzz']}, {'platforms': ['aaa']}
 468       ]
 469     }))
 470     self.assertFalse(self.writer.IsPolicySupported({
 471       'supported_on': [
 472         {'platforms': ['mac', 'linux']}, {'platforms': ['aaa']}
 473       ]
 474     }))
 475
 476
 477 if __name__ == '__main__':
 478   unittest.main()