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