src/tools/grit/grit/format/policy_templates/writers/adml_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.adml_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 adml_writer
  18 from grit.format.policy_templates.writers import xml_writer_base_unittest
  19
  20
  21 class AdmlWriterUnittest(xml_writer_base_unittest.XmlWriterBaseTest):
  22
  23   def setUp(self):
  24     config = {
  25       'app_name': 'test',
  26       'build': 'test',
  27       'win_supported_os': 'SUPPORTED_TESTOS',
  28     }
  29     self.writer = adml_writer.GetWriter(config)
  30     self.writer.messages = {
  31       'win_supported_winxpsp2': {
  32         'text': 'Supported on Test OS or higher',
  33         'desc': 'blah'
  34       },
  35       'doc_recommended': {
  36         'text': 'Recommended',
  37         'desc': 'bleh'
  38       },
  39     }
  40     self.writer.Init()
  41
  42   def _InitWriterForAddingPolicyGroups(self, writer):
  43     '''Initialize the writer for adding policy groups. This method must be
  44     called before the method "BeginPolicyGroup" can be called. It initializes
  45     attributes of the writer.
  46     '''
  47     writer.BeginTemplate()
  48
  49   def _InitWriterForAddingPolicies(self, writer, policy):
  50     '''Initialize the writer for adding policies. This method must be
  51     called before the method "WritePolicy" can be called. It initializes
  52     attributes of the writer.
  53     '''
  54     self._InitWriterForAddingPolicyGroups(writer)
  55     policy_group = {
  56       'name': 'PolicyGroup',
  57       'caption': 'Test Caption',
  58       'desc': 'This is the test description of the test policy group.',
  59       'policies': policy,
  60     }
  61     writer.BeginPolicyGroup(policy_group)
  62
  63     string_elements = \
  64         self.writer._string_table_elem.getElementsByTagName('string')
  65     for elem in string_elements:
  66       self.writer._string_table_elem.removeChild(elem)
  67
  68   def testEmpty(self):
  69     self.writer.BeginTemplate()
  70     self.writer.EndTemplate()
  71     output = self.writer.GetTemplateText()
  72     expected_output = (
  73         '<?xml version="1.0" ?><policyDefinitionResources'
  74         ' revision="1.0" schemaVersion="1.0"><displayName/><description/>'
  75         '<resources><stringTable><string id="SUPPORTED_TESTOS">Supported on'
  76         ' Test OS or higher</string></stringTable><presentationTable/>'
  77         '</resources></policyDefinitionResources>')
  78     self.AssertXMLEquals(output, expected_output)
  79
  80   def testVersionAnnotation(self):
  81     self.writer.config['version'] = '39.0.0.0'
  82     self.writer.BeginTemplate()
  83     self.writer.EndTemplate()
  84     output = self.writer.GetTemplateText()
  85     expected_output = (
  86         '<?xml version="1.0" ?><policyDefinitionResources'
  87         ' revision="1.0" schemaVersion="1.0"><!--test version: 39.0.0.0-->'
  88         '<displayName/><description/><resources><stringTable>'
  89         '<string id="SUPPORTED_TESTOS">Supported on'
  90         ' Test OS or higher</string></stringTable><presentationTable/>'
  91         '</resources></policyDefinitionResources>')
  92     self.AssertXMLEquals(output, expected_output)
  93
  94   def testPolicyGroup(self):
  95     empty_policy_group = {
  96       'name': 'PolicyGroup',
  97       'caption': 'Test Group Caption',
  98       'desc': 'This is the test description of the test policy group.',
  99       'policies': [
 100           {'name': 'PolicyStub2',
 101            'type': 'main'},
 102           {'name': 'PolicyStub1',
 103            'type': 'main'},
 104       ],
 105     }
 106     self._InitWriterForAddingPolicyGroups(self.writer)
 107     self.writer.BeginPolicyGroup(empty_policy_group)
 108     self.writer.EndPolicyGroup
 109     # Assert generated string elements.
 110     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 111     expected_output = (
 112         '<string id="SUPPORTED_TESTOS">'
 113         'Supported on Test OS or higher</string>\n'
 114         '<string id="PolicyGroup_group">Test Group Caption</string>')
 115     self.AssertXMLEquals(output, expected_output)
 116     # Assert generated presentation elements.
 117     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 118     expected_output = ''
 119     self.AssertXMLEquals(output, expected_output)
 120
 121   def testMainPolicy(self):
 122     main_policy = {
 123       'name': 'DummyMainPolicy',
 124       'type': 'main',
 125       'caption': 'Main policy caption',
 126       'desc': 'Main policy test description.'
 127     }
 128     self. _InitWriterForAddingPolicies(self.writer, main_policy)
 129     self.writer.WritePolicy(main_policy)
 130     # Assert generated string elements.
 131     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 132     expected_output = (
 133         '<string id="DummyMainPolicy">Main policy caption</string>\n'
 134         '<string id="DummyMainPolicy_Explain">'
 135         'Main policy test description.</string>')
 136     self.AssertXMLEquals(output, expected_output)
 137     # Assert generated presentation elements.
 138     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 139     expected_output = '<presentation id="DummyMainPolicy"/>'
 140     self.AssertXMLEquals(output, expected_output)
 141
 142   def testStringPolicy(self):
 143     string_policy = {
 144       'name': 'StringPolicyStub',
 145       'type': 'string',
 146       'caption': 'String policy caption',
 147       'label': 'String policy label',
 148       'desc': 'This is a test description.',
 149     }
 150     self. _InitWriterForAddingPolicies(self.writer, string_policy)
 151     self.writer.WritePolicy(string_policy)
 152     # Assert generated string elements.
 153     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 154     expected_output = (
 155         '<string id="StringPolicyStub">String policy caption</string>\n'
 156         '<string id="StringPolicyStub_Explain">'
 157         'This is a test description.</string>')
 158     self.AssertXMLEquals(output, expected_output)
 159     # Assert generated presentation elements.
 160     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 161     expected_output = (
 162         '<presentation id="StringPolicyStub">\n'
 163         '  <textBox refId="StringPolicyStub">\n'
 164         '    <label>String policy label</label>\n'
 165         '  </textBox>\n'
 166         '</presentation>')
 167     self.AssertXMLEquals(output, expected_output)
 168
 169   def testIntPolicy(self):
 170     int_policy = {
 171       'name': 'IntPolicyStub',
 172       'type': 'int',
 173       'caption': 'Int policy caption',
 174       'label': 'Int policy label',
 175       'desc': 'This is a test description.',
 176     }
 177     self. _InitWriterForAddingPolicies(self.writer, int_policy)
 178     self.writer.WritePolicy(int_policy)
 179     # Assert generated string elements.
 180     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 181     expected_output = (
 182         '<string id="IntPolicyStub">Int policy caption</string>\n'
 183         '<string id="IntPolicyStub_Explain">'
 184         'This is a test description.</string>')
 185     self.AssertXMLEquals(output, expected_output)
 186     # Assert generated presentation elements.
 187     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 188     expected_output = (
 189         '<presentation id="IntPolicyStub">\n'
 190         '  <decimalTextBox refId="IntPolicyStub">'
 191         'Int policy label:</decimalTextBox>\n'
 192         '</presentation>')
 193     self.AssertXMLEquals(output, expected_output)
 194
 195   def testIntEnumPolicy(self):
 196     enum_policy = {
 197       'name': 'EnumPolicyStub',
 198       'type': 'int-enum',
 199       'caption': 'Enum policy caption',
 200       'label': 'Enum policy label',
 201       'desc': 'This is a test description.',
 202       'items': [
 203           {
 204            'name': 'item 1',
 205            'value': 1,
 206            'caption': 'Caption Item 1',
 207           },
 208           {
 209            'name': 'item 2',
 210            'value': 2,
 211            'caption': 'Caption Item 2',
 212           },
 213       ],
 214     }
 215     self. _InitWriterForAddingPolicies(self.writer, enum_policy)
 216     self.writer.WritePolicy(enum_policy)
 217     # Assert generated string elements.
 218     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 219     expected_output = (
 220         '<string id="EnumPolicyStub">Enum policy caption</string>\n'
 221         '<string id="EnumPolicyStub_Explain">'
 222         'This is a test description.</string>\n'
 223         '<string id="item 1">Caption Item 1</string>\n'
 224         '<string id="item 2">Caption Item 2</string>')
 225     self.AssertXMLEquals(output, expected_output)
 226     # Assert generated presentation elements.
 227     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 228     expected_output = (
 229         '<presentation id="EnumPolicyStub">\n'
 230         '  <dropdownList refId="EnumPolicyStub">'
 231         'Enum policy label</dropdownList>\n'
 232         '</presentation>')
 233     self.AssertXMLEquals(output, expected_output)
 234
 235   def testStringEnumPolicy(self):
 236     enum_policy = {
 237       'name': 'EnumPolicyStub',
 238       'type': 'string-enum',
 239       'caption': 'Enum policy caption',
 240       'label': 'Enum policy label',
 241       'desc': 'This is a test description.',
 242       'items': [
 243           {
 244            'name': 'item 1',
 245            'value': 'value 1',
 246            'caption': 'Caption Item 1',
 247           },
 248           {
 249            'name': 'item 2',
 250            'value': 'value 2',
 251            'caption': 'Caption Item 2',
 252           },
 253       ],
 254     }
 255     self. _InitWriterForAddingPolicies(self.writer, enum_policy)
 256     self.writer.WritePolicy(enum_policy)
 257     # Assert generated string elements.
 258     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 259     expected_output = (
 260         '<string id="EnumPolicyStub">Enum policy caption</string>\n'
 261         '<string id="EnumPolicyStub_Explain">'
 262         'This is a test description.</string>\n'
 263         '<string id="item 1">Caption Item 1</string>\n'
 264         '<string id="item 2">Caption Item 2</string>')
 265     self.AssertXMLEquals(output, expected_output)
 266     # Assert generated presentation elements.
 267     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 268     expected_output = (
 269         '<presentation id="EnumPolicyStub">\n'
 270         '  <dropdownList refId="EnumPolicyStub">'
 271         'Enum policy label</dropdownList>\n'
 272         '</presentation>')
 273     self.AssertXMLEquals(output, expected_output)
 274
 275   def testListPolicy(self):
 276     list_policy = {
 277       'name': 'ListPolicyStub',
 278       'type': 'list',
 279       'caption': 'List policy caption',
 280       'label': 'List policy label',
 281       'desc': 'This is a test description.',
 282     }
 283     self. _InitWriterForAddingPolicies(self.writer, list_policy)
 284     self.writer.WritePolicy(list_policy)
 285     # Assert generated string elements.
 286     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 287     expected_output = (
 288         '<string id="ListPolicyStub">List policy caption</string>\n'
 289         '<string id="ListPolicyStub_Explain">'
 290         'This is a test description.</string>\n'
 291         '<string id="ListPolicyStubDesc">List policy caption</string>')
 292     self.AssertXMLEquals(output, expected_output)
 293     # Assert generated presentation elements.
 294     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 295     expected_output = (
 296         '<presentation id="ListPolicyStub">\n'
 297         '  <listBox refId="ListPolicyStubDesc">List policy label</listBox>\n'
 298         '</presentation>')
 299     self.AssertXMLEquals(output, expected_output)
 300
 301   def testStringEnumListPolicy(self):
 302     list_policy = {
 303       'name': 'ListPolicyStub',
 304       'type': 'string-enum-list',
 305       'caption': 'List policy caption',
 306       'label': 'List policy label',
 307       'desc': 'This is a test description.',
 308       'items': [
 309           {
 310            'name': 'item 1',
 311            'value': 'value 1',
 312            'caption': 'Caption Item 1',
 313           },
 314           {
 315            'name': 'item 2',
 316            'value': 'value 2',
 317            'caption': 'Caption Item 2',
 318           },
 319       ],
 320     }
 321     self. _InitWriterForAddingPolicies(self.writer, list_policy)
 322     self.writer.WritePolicy(list_policy)
 323     # Assert generated string elements.
 324     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 325     expected_output = (
 326         '<string id="ListPolicyStub">List policy caption</string>\n'
 327         '<string id="ListPolicyStub_Explain">'
 328         'This is a test description.</string>\n'
 329         '<string id="ListPolicyStubDesc">List policy caption</string>')
 330     self.AssertXMLEquals(output, expected_output)
 331     # Assert generated presentation elements.
 332     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 333     expected_output = (
 334         '<presentation id="ListPolicyStub">\n'
 335         '  <listBox refId="ListPolicyStubDesc">List policy label</listBox>\n'
 336         '</presentation>')
 337     self.AssertXMLEquals(output, expected_output)
 338
 339   def testDictionaryPolicy(self):
 340     dict_policy = {
 341       'name': 'DictionaryPolicyStub',
 342       'type': 'dict',
 343       'caption': 'Dictionary policy caption',
 344       'label': 'Dictionary policy label',
 345       'desc': 'This is a test description.',
 346     }
 347     self. _InitWriterForAddingPolicies(self.writer, dict_policy)
 348     self.writer.WritePolicy(dict_policy)
 349     # Assert generated string elements.
 350     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 351     expected_output = (
 352         '<string id="DictionaryPolicyStub">Dictionary policy caption</string>\n'
 353         '<string id="DictionaryPolicyStub_Explain">'
 354         'This is a test description.</string>')
 355     self.AssertXMLEquals(output, expected_output)
 356     # Assert generated presentation elements.
 357     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 358     expected_output = (
 359         '<presentation id="DictionaryPolicyStub">\n'
 360         '  <textBox refId="DictionaryPolicyStub">\n'
 361         '    <label>Dictionary policy label</label>\n'
 362         '  </textBox>\n'
 363         '</presentation>')
 364     self.AssertXMLEquals(output, expected_output)
 365
 366   def testPlatform(self):
 367     # Test that the writer correctly chooses policies of platform Windows.
 368     self.assertTrue(self.writer.IsPolicySupported({
 369       'supported_on': [
 370         {'platforms': ['win', 'zzz']}, {'platforms': ['aaa']}
 371       ]
 372     }))
 373     self.assertFalse(self.writer.IsPolicySupported({
 374       'supported_on': [
 375         {'platforms': ['mac', 'linux']}, {'platforms': ['aaa']}
 376       ]
 377     }))
 378
 379   def testStringEncodings(self):
 380     enum_policy_a = {
 381       'name': 'EnumPolicy.A',
 382       'type': 'string-enum',
 383       'caption': 'Enum policy A caption',
 384       'label': 'Enum policy A label',
 385       'desc': 'This is a test description.',
 386       'items': [
 387           {
 388            'name': 'tls1.2',
 389            'value': 'tls1.2',
 390            'caption': 'tls1.2',
 391           }
 392       ],
 393     }
 394     enum_policy_b = {
 395       'name': 'EnumPolicy.B',
 396       'type': 'string-enum',
 397       'caption': 'Enum policy B caption',
 398       'label': 'Enum policy B label',
 399       'desc': 'This is a test description.',
 400       'items': [
 401           {
 402            'name': 'tls1.2',
 403            'value': 'tls1.2',
 404            'caption': 'tls1.2',
 405           }
 406       ],
 407     }
 408     self. _InitWriterForAddingPolicies(self.writer, enum_policy_a)
 409     self.writer.WritePolicy(enum_policy_a)
 410     self.writer.WritePolicy(enum_policy_b)
 411     # Assert generated string elements.
 412     output = self.GetXMLOfChildren(self.writer._string_table_elem)
 413     expected_output = (
 414         '<string id="EnumPolicy_A">Enum policy A caption</string>\n'
 415         '<string id="EnumPolicy_A_Explain">'
 416         'This is a test description.</string>\n'
 417         '<string id="tls1_2">tls1.2</string>\n'
 418         '<string id="EnumPolicy_B">Enum policy B caption</string>\n'
 419         '<string id="EnumPolicy_B_Explain">'
 420         'This is a test description.</string>\n')
 421     self.AssertXMLEquals(output, expected_output)
 422     # Assert generated presentation elements.
 423     output = self.GetXMLOfChildren(self.writer._presentation_table_elem)
 424     expected_output = (
 425         '<presentation id="EnumPolicy.A">\n'
 426         '  <dropdownList refId="EnumPolicy.A">'
 427         'Enum policy A label</dropdownList>\n'
 428         '</presentation>\n'
 429         '<presentation id="EnumPolicy.B">\n'
 430         '  <dropdownList refId="EnumPolicy.B">'
 431         'Enum policy B label</dropdownList>\n'
 432         '</presentation>')
 433     self.AssertXMLEquals(output, expected_output)
 434
 435
 436 if __name__ == '__main__':
 437   unittest.main()