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 |