Added schemas to policy templates.

chrome/app/policy/syntax_check_policy_template_json.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 '''
 Checks a policy_templates.json file for conformity to its syntax specification.
 '''
 
 import json
 import optparse
 import os
 import re
 import sys
 
 
 LEADING_WHITESPACE = re.compile('^([ \t]*)')
 TRAILING_WHITESPACE = re.compile('.*?([ \t]+)$')
 # Matches all non-empty strings that contain no whitespaces.
 NO_WHITESPACE = re.compile('[^\s]+$')
 
+# Convert a 'type' to its corresponding schema type.
+TYPE_TO_SCHEMA = {
+  'int': 'integer',

[Mattias Nissler (ping if slow), 2012/07/31 11:46:34]

Suggestion: You could just put the entire expected schema dictionary here?
Python seems to compare dictionaries just fine.

[Joao da Silva, 2012/07/31 12:56:48]

'dicts' and the '-enums' have extra fields that aren't always the same, so a
simple equality test would fail on those cases. Testing that the 'schema' is a
subset of an expected dictionary would work, but I couldn't find anything in the
python libraries that does that.

Shouldn't take too much to write a custom function for that, but this is
transitional code anyway, so I'll pass :-)

+  'list': 'array',
+  'dict': 'object',
+  'main': 'boolean',
+  'string': 'string',
+  'int-enum': 'integer',
+  'string-enum': 'string',
+}
 
 class PolicyTemplateChecker(object):
 
   def __init__(self):
     self.error_count = 0
     self.warning_count = 0
     self.num_policies = 0
     self.num_groups = 0
     self.num_policies_in_groups = 0
     self.options = None
@@ skipping 73 matching lines @@
     '''
     Checks a set of policy_ids to make sure it contains a continuous range
     of entries (i.e. no holes).
     Holes would not be a technical problem, but we want to ensure that nobody
     accidentally omits IDs.
     '''
     for i in range(len(policy_ids)):
       if (i + 1) not in policy_ids:
         self._Error('No policy with id: %s' % (i + 1))
 
+  def _CheckPolicySchema(self, policy, policy_type):
+    '''Checks that the 'schema' field matches the 'type' field.'''
+    self._CheckContains(policy, 'schema', dict)
+    if isinstance(policy.get('schema'), dict):
+      self._CheckContains(policy['schema'], 'type', str)
+      if policy['schema'].get('type') != TYPE_TO_SCHEMA[policy_type]:
+        self._Error('Schema type must match the existing type for policy %s' %
+            policy.get('name'))

[Mattias Nissler (ping if slow), 2012/07/31 11:46:34]

nit: Elsewhere in this file, the continuation is aligned at the opening
parenthesis.

[Joao da Silva, 2012/07/31 12:56:48]

Done.

+
   def _CheckPolicy(self, policy, is_in_group, policy_ids):
     if not isinstance(policy, dict):
       self._Error('Each policy must be a dictionary.', 'policy', None, policy)
       return
 
     # There should not be any unknown keys in |policy|.
     for key in policy:
       if key not in ('name', 'type', 'caption', 'desc', 'device_only',
                      'supported_on', 'label', 'policies', 'items',
                      'example_value', 'features', 'deprecated', 'future',
-                     'id'):
+                     'id', 'schema'):
         self.warning_count += 1
         print ('In policy %s: Warning: Unknown key: %s' %
                (policy.get('name'), key))
 
     # Each policy must have a name.
     self._CheckContains(policy, 'name', str, regexp_check=NO_WHITESPACE)
 
     # Each policy must have a type.
     policy_type = self._CheckContains(policy, 'type', str)
     if policy_type not in ('group', 'main', 'string', 'int', 'list', 'int-enum',
@@ skipping 38 matching lines @@
                     'policy', policy)
 
       # Statistics.
       self.num_groups += 1
     else:  # policy_type != group
 
       # Each policy must have a protobuf ID.
       id = self._CheckContains(policy, 'id', int)
       self._AddPolicyID(id, policy_ids, policy)
 
+      # 'schema' is the new 'type'.
+      # TODO(joaodasilva): remove the 'type' checks once 'schema' is used
+      # everywhere.
+      self._CheckPolicySchema(policy, policy_type)
+
       # Each policy must have a supported_on list.
       supported_on = self._CheckContains(policy, 'supported_on', list)
       if supported_on is not None:
         for s in supported_on:
           if not isinstance(s, str):
             self._Error('Entries in "supported_on" must be strings.', 'policy',
                         policy, supported_on)
 
       # Each policy must have a 'features' dict.
       self._CheckContains(policy, 'features', dict)
@@ skipping 216 matching lines @@
     if filename is None:
       if len(args) != 2:
         parser.print_help()
         sys.exit(1)
       filename = args[1]
     return self.Main(filename, options)
 
 
 if __name__ == '__main__':
   sys.exit(PolicyTemplateChecker().Run(sys.argv))