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
10import os
11import sys
12import unittest
13if __name__ == '__main__':
14  sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..'))
15
16
17from grit.format.policy_templates.writers import admx_writer
18from grit.format.policy_templates.writers import xml_writer_base_unittest
19from xml.dom import minidom
20
21
22class 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
477if __name__ == '__main__':
478  unittest.main()
479