src/tools/grit/grit/format/policy_templates/writers/reg_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 '''Unit tests for grit.format.policy_templates.writers.reg_writer'''
   8
   9
  10 import os
  11 import sys
  12 if __name__ == '__main__':
  13   sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..'))
  14
  15 import unittest
  16
  17 from grit.format.policy_templates.writers import writer_unittest_common
  18
  19
  20 class RegWriterUnittest(writer_unittest_common.WriterUnittestCommon):
  21   '''Unit tests for RegWriter.'''
  22
  23   NEWLINE = '\r\n'
  24
  25   def CompareOutputs(self, output, expected_output):
  26     '''Compares the output of the reg_writer with its expected output.
  27
  28     Args:
  29       output: The output of the reg writer as returned by grit.
  30       expected_output: The expected output.
  31
  32     Raises:
  33       AssertionError: if the two strings are not equivalent.
  34     '''
  35     self.assertEquals(
  36         output.strip(),
  37         expected_output.strip())
  38
  39   def testEmpty(self):
  40     # Test the handling of an empty policy list.
  41     grd = self.PrepareTest(
  42         '{'
  43         '  "policy_definitions": [],'
  44         '  "placeholders": [],'
  45         '  "messages": {}'
  46         '}')
  47     output = self.GetOutput(grd, 'fr', {'_chromium': '1', }, 'reg', 'en')
  48     expected_output = 'Windows Registry Editor Version 5.00'
  49     self.CompareOutputs(output, expected_output)
  50
  51   def testEmptyVersion(self):
  52     # Test the handling of an empty policy list.
  53     grd = self.PrepareTest(
  54         '{'
  55         '  "policy_definitions": [],'
  56         '  "placeholders": [],'
  57         '  "messages": {}'
  58         '}')
  59     output = self.GetOutput(
  60         grd, 'fr', {'_chromium': '1', 'version': '39.0.0.0' }, 'reg', 'en')
  61     expected_output = ('Windows Registry Editor Version 5.00\r\n'
  62                        '; chromium version: 39.0.0.0\r\n')
  63     self.CompareOutputs(output, expected_output)
  64
  65   def testMainPolicy(self):
  66     # Tests a policy group with a single policy of type 'main'.
  67     grd = self.PrepareTest(
  68         '{'
  69         '  "policy_definitions": ['
  70         '    {'
  71         '      "name": "MainPolicy",'
  72         '      "type": "main",'
  73         '      "features": { "can_be_recommended": True },'
  74         '      "caption": "",'
  75         '      "desc": "",'
  76         '      "supported_on": ["chrome.win:8-"],'
  77         '      "example_value": True'
  78         '    },'
  79         '  ],'
  80         '  "placeholders": [],'
  81         '  "messages": {},'
  82         '}')
  83     output = self.GetOutput(grd, 'fr', {'_google_chrome' : '1'}, 'reg', 'en')
  84     expected_output = self.NEWLINE.join([
  85         'Windows Registry Editor Version 5.00',
  86         '',
  87         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Google\\Chrome]',
  88         '"MainPolicy"=dword:00000001',
  89         '',
  90         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Google\\Chrome\\Recommended]',
  91         '"MainPolicy"=dword:00000001'])
  92     self.CompareOutputs(output, expected_output)
  93
  94   def testRecommendedMainPolicy(self):
  95     # Tests a policy group with a single policy of type 'main'.
  96     grd = self.PrepareTest(
  97         '{'
  98         '  "policy_definitions": ['
  99         '    {'
 100         '      "name": "MainPolicy",'
 101         '      "type": "main",'
 102         '      "features": {'
 103         '        "can_be_recommended": True,'
 104         '        "can_be_mandatory": False '
 105         '      },'
 106         '      "caption": "",'
 107         '      "desc": "",'
 108         '      "supported_on": ["chrome.win:8-"],'
 109         '      "example_value": True'
 110         '    },'
 111         '  ],'
 112         '  "placeholders": [],'
 113         '  "messages": {},'
 114         '}')
 115     output = self.GetOutput(grd, 'fr', {'_google_chrome' : '1'}, 'reg', 'en')
 116     expected_output = self.NEWLINE.join([
 117         'Windows Registry Editor Version 5.00',
 118         '',
 119         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Google\\Chrome\\Recommended]',
 120         '"MainPolicy"=dword:00000001'])
 121     self.CompareOutputs(output, expected_output)
 122
 123   def testStringPolicy(self):
 124     # Tests a policy group with a single policy of type 'string'.
 125     grd = self.PrepareTest(
 126         '{'
 127         '  "policy_definitions": ['
 128         '    {'
 129         '      "name": "StringPolicy",'
 130         '      "type": "string",'
 131         '      "caption": "",'
 132         '      "desc": "",'
 133         '      "supported_on": ["chrome.win:8-"],'
 134         '      "example_value": "hello, world! \\\" \\\\"'
 135         '    },'
 136         '  ],'
 137         '  "placeholders": [],'
 138         '  "messages": {},'
 139         '}')
 140     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 141     expected_output = self.NEWLINE.join([
 142         'Windows Registry Editor Version 5.00',
 143         '',
 144         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium]',
 145         '"StringPolicy"="hello, world! \\\" \\\\"'])
 146     self.CompareOutputs(output, expected_output)
 147
 148   def testIntPolicy(self):
 149     # Tests a policy group with a single policy of type 'int'.
 150     grd = self.PrepareTest(
 151         '{'
 152         '  "policy_definitions": ['
 153         '    {'
 154         '      "name": "IntPolicy",'
 155         '      "type": "int",'
 156         '      "caption": "",'
 157         '      "desc": "",'
 158         '      "supported_on": ["chrome.win:8-"],'
 159         '      "example_value": 26'
 160         '    },'
 161         '  ],'
 162         '  "placeholders": [],'
 163         '  "messages": {},'
 164         '}')
 165     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 166     expected_output = self.NEWLINE.join([
 167         'Windows Registry Editor Version 5.00',
 168         '',
 169         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium]',
 170         '"IntPolicy"=dword:0000001a'])
 171     self.CompareOutputs(output, expected_output)
 172
 173   def testIntEnumPolicy(self):
 174     # Tests a policy group with a single policy of type 'int-enum'.
 175     grd = self.PrepareTest(
 176         '{'
 177         '  "policy_definitions": ['
 178         '    {'
 179         '      "name": "EnumPolicy",'
 180         '      "type": "int-enum",'
 181         '      "caption": "",'
 182         '      "desc": "",'
 183         '      "items": ['
 184         '        {"name": "ProxyServerDisabled", "value": 0, "caption": ""},'
 185         '        {"name": "ProxyServerAutoDetect", "value": 1, "caption": ""},'
 186         '      ],'
 187         '      "supported_on": ["chrome.win:8-"],'
 188         '      "example_value": 1'
 189         '    },'
 190         '  ],'
 191         '  "placeholders": [],'
 192         '  "messages": {},'
 193         '}')
 194     output = self.GetOutput(grd, 'fr', {'_google_chrome': '1'}, 'reg', 'en')
 195     expected_output = self.NEWLINE.join([
 196         'Windows Registry Editor Version 5.00',
 197         '',
 198         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Google\\Chrome]',
 199         '"EnumPolicy"=dword:00000001'])
 200     self.CompareOutputs(output, expected_output)
 201
 202   def testStringEnumPolicy(self):
 203     # Tests a policy group with a single policy of type 'string-enum'.
 204     grd = self.PrepareTest(
 205         '{'
 206         '  "policy_definitions": ['
 207         '    {'
 208         '      "name": "EnumPolicy",'
 209         '      "type": "string-enum",'
 210         '      "caption": "",'
 211         '      "desc": "",'
 212         '      "items": ['
 213         '        {"name": "ProxyServerDisabled", "value": "one",'
 214         '         "caption": ""},'
 215         '        {"name": "ProxyServerAutoDetect", "value": "two",'
 216                 '         "caption": ""},'
 217         '      ],'
 218         '      "supported_on": ["chrome.win:8-"],'
 219         '      "example_value": "two"'
 220         '    },'
 221         '  ],'
 222         '  "placeholders": [],'
 223         '  "messages": {},'
 224         '}')
 225     output = self.GetOutput(grd, 'fr', {'_google_chrome': '1'}, 'reg', 'en')
 226     expected_output = self.NEWLINE.join([
 227         'Windows Registry Editor Version 5.00',
 228         '',
 229         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Google\\Chrome]',
 230         '"EnumPolicy"="two"'])
 231     self.CompareOutputs(output, expected_output)
 232
 233   def testListPolicy(self):
 234     # Tests a policy group with a single policy of type 'list'.
 235     grd = self.PrepareTest(
 236         '{'
 237         '  "policy_definitions": ['
 238         '    {'
 239         '      "name": "ListPolicy",'
 240         '      "type": "list",'
 241         '      "caption": "",'
 242         '      "desc": "",'
 243         '      "supported_on": ["chrome.linux:8-"],'
 244         '      "example_value": ["foo", "bar"]'
 245         '    },'
 246         '  ],'
 247         '  "placeholders": [],'
 248         '  "messages": {},'
 249         '}')
 250     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 251     expected_output = self.NEWLINE.join([
 252         'Windows Registry Editor Version 5.00',
 253         '',
 254         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium\\ListPolicy]',
 255         '"1"="foo"',
 256         '"2"="bar"'])
 257
 258   def testStringEnumListPolicy(self):
 259     # Tests a policy group with a single policy of type 'string-enum-list'.
 260     grd = self.PrepareTest(
 261         '{'
 262         '  "policy_definitions": ['
 263         '    {'
 264         '      "name": "ListPolicy",'
 265         '      "type": "string-enum-list",'
 266         '      "caption": "",'
 267         '      "desc": "",'
 268         '      "items": ['
 269         '        {"name": "ProxyServerDisabled", "value": "foo",'
 270         '         "caption": ""},'
 271         '        {"name": "ProxyServerAutoDetect", "value": "bar",'
 272                 '         "caption": ""},'
 273         '      ],'
 274         '      "supported_on": ["chrome.linux:8-"],'
 275         '      "example_value": ["foo", "bar"]'
 276         '    },'
 277         '  ],'
 278         '  "placeholders": [],'
 279         '  "messages": {},'
 280         '}')
 281     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 282     expected_output = self.NEWLINE.join([
 283         'Windows Registry Editor Version 5.00',
 284         '',
 285         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium\\ListPolicy]',
 286         '"1"="foo"',
 287         '"2"="bar"'])
 288
 289   def testDictionaryPolicy(self):
 290     # Tests a policy group with a single policy of type 'dict'.
 291     example = {
 292       'bool': True,
 293       'dict': {
 294         'a': 1,
 295         'b': 2,
 296       },
 297       'int': 10,
 298       'list': [1, 2, 3],
 299       'string': 'abc',
 300     }
 301     grd = self.PrepareTest(
 302         '{'
 303         '  "policy_definitions": ['
 304         '    {'
 305         '      "name": "DictionaryPolicy",'
 306         '      "type": "dict",'
 307         '      "caption": "",'
 308         '      "desc": "",'
 309         '      "supported_on": ["chrome.win:8-"],'
 310         '      "example_value": ' + str(example) +
 311         '    },'
 312         '  ],'
 313         '  "placeholders": [],'
 314         '  "messages": {},'
 315         '}')
 316     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 317     expected_output = self.NEWLINE.join([
 318         'Windows Registry Editor Version 5.00',
 319         '',
 320         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium]',
 321         '"DictionaryPolicy"="{"bool": true, "dict": {"a": 1, '
 322         '"b": 2}, "int": 10, "list": [1, 2, 3], "string": "abc"}"'])
 323     self.CompareOutputs(output, expected_output)
 324
 325   def testNonSupportedPolicy(self):
 326     # Tests a policy that is not supported on Windows, so it shouldn't
 327     # be included in the .REG file.
 328     grd = self.PrepareTest(
 329         '{'
 330         '  "policy_definitions": ['
 331         '    {'
 332         '      "name": "NonWindowsPolicy",'
 333         '      "type": "list",'
 334         '      "caption": "",'
 335         '      "desc": "",'
 336         '      "supported_on": ["chrome.mac:8-"],'
 337         '      "example_value": ["a"]'
 338         '    },'
 339         '  ],'
 340         '  "placeholders": [],'
 341         '  "messages": {},'
 342         '}')
 343     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 344     expected_output = self.NEWLINE.join([
 345         'Windows Registry Editor Version 5.00'])
 346     self.CompareOutputs(output, expected_output)
 347
 348   def testPolicyGroup(self):
 349     # Tests a policy group that has more than one policies.
 350     grd = self.PrepareTest(
 351         '{'
 352         '  "policy_definitions": ['
 353         '    {'
 354         '      "name": "Group1",'
 355         '      "type": "group",'
 356         '      "caption": "",'
 357         '      "desc": "",'
 358         '      "policies": [{'
 359         '        "name": "Policy1",'
 360         '        "type": "list",'
 361         '        "caption": "",'
 362         '        "desc": "",'
 363         '        "supported_on": ["chrome.win:8-"],'
 364         '        "example_value": ["a", "b"]'
 365         '      },{'
 366         '        "name": "Policy2",'
 367         '        "type": "string",'
 368         '        "caption": "",'
 369         '        "desc": "",'
 370         '        "supported_on": ["chrome.win:8-"],'
 371         '        "example_value": "c"'
 372         '      }],'
 373         '    },'
 374         '  ],'
 375         '  "placeholders": [],'
 376         '  "messages": {},'
 377         '}')
 378     output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'reg', 'en')
 379     expected_output = self.NEWLINE.join([
 380         'Windows Registry Editor Version 5.00',
 381         '',
 382         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium]',
 383         '"Policy2"="c"',
 384         '',
 385         '[HKEY_LOCAL_MACHINE\\Software\\Policies\\Chromium\\Policy1]',
 386         '"1"="a"',
 387         '"2"="b"'])
 388     self.CompareOutputs(output, expected_output)
 389
 390
 391 if __name__ == '__main__':
 392   unittest.main()