Support API aliases

tools/json_schema_compiler/feature_compiler_test.py

 #!/usr/bin/env python
 # Copyright 2015 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.
 
 import feature_compiler
 import unittest
 
 class FeatureCompilerTest(unittest.TestCase):
   """Test the FeatureCompiler. Note that we test that the expected features are
   generated more thoroughly in features_generation_unittest.cc. And, of course,
   this is most exhaustively tested through Chrome's compilation process (if a
   feature fails to parse, the compile fails).
   These tests primarily focus on catching errors during parsing.
   """
   def _parseFeature(self, value):
     """Parses a feature from the given value and returns the result."""
     f = feature_compiler.Feature('alpha')
     f.Parse(value)
     return f
 
+  def _createTestFeatureCompiler(self, feature_class):
+    return feature_compiler.FeatureCompiler('chrome_root', [], feature_class,
+        'provider_class', 'out_root', 'out_base_filename')
+
   def _hasError(self, f, error):
     """Asserts that |error| is present somewhere in the given feature's
     errors."""
-    self.assertTrue(f.errors)
-    self.assertNotEqual(-1, str(f.errors).find(error), str(f.errors))
+    errors = f.GetErrors()
+    self.assertTrue(errors)
+    self.assertNotEqual(-1, str(errors).find(error), str(errors))
 
   def setUp(self):
     feature_compiler.ENABLE_ASSERTIONS = False
     feature_compiler.STRINGS_TO_UNICODE = True
 
   def testFeature(self):
     # Test some basic feature parsing for a sanity check.
     f = self._parseFeature({
+      'alias': 'feature',
       'blacklist': ['aaa', 'bbb'],
       'channel': 'stable',
       'command_line_switch': 'switch',
       'component_extensions_auto_granted': False,
       'contexts': ['blessed_extension', 'blessed_web_page'],
       'default_parent': True,
       'dependencies': ['dependency1', 'dependency2'],
       'extension_types': ['extension'],
       'location': 'component',
       'internal': True,
       'matches': ['*://*/*'],
       'max_manifest_version': 1,
       'noparent': True,
       'platforms': ['mac', 'win'],
       'session_types': ['kiosk', 'regular'],
+      'source': 'feature',
       'whitelist': ['zzz', 'yyy']
     })
-    self.assertFalse(f.errors)
+    self.assertFalse(f.GetErrors())
 
   def testInvalidAll(self):
     f = self._parseFeature({
       'channel': 'stable',
       'dependencies': 'all',
     })
     self._hasError(f, 'Illegal value: "all"')
 
   def testUnknownKeyError(self):
     f = self._parseFeature({
@@ skipping 66 matching lines @@
     permission_feature.Validate('PermissionFeature')
     self._hasError(permission_feature,
                    'Features must specify either a channel or dependencies')
     manifest_feature = self._parseFeature({'extension_types': ['extension']})
     manifest_feature.Validate('ManifestFeature')
     self._hasError(manifest_feature,
                    'Features must specify either a channel or dependencies')
     channel_feature = self._parseFeature({'contexts': ['blessed_extension'],
                                           'channel': 'trunk'})
     channel_feature.Validate('APIFeature')
-    self.assertFalse(channel_feature.errors)
+    self.assertFalse(channel_feature.GetErrors())
     dependency_feature = self._parseFeature(
                              {'contexts': ['blessed_extension'],
                               'dependencies': ['alpha']})
     dependency_feature.Validate('APIFeature')
-    self.assertFalse(dependency_feature.errors)
+    self.assertFalse(dependency_feature.GetErrors())
 
+  def testAliasInComplexFeature(self):
+    compiler = self._createTestFeatureCompiler('APIFeature')
+    compiler._CompileFeature('feature_alpha', [{
+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'alias': 'feature_beta'
+    }, {
+      'contexts': ['blessed_extension'],
+      'channel': 'beta'
+    }]);
+    feature = compiler._features.get('feature_alpha')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+  def testMultipleAliasesInComplexFeature(self):
+    compiler = self._createTestFeatureCompiler('APIFeature')
+    compiler._CompileFeature('feature_alpha', [{
+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'alias': 'feature_beta'
+    }, {
+      'contexts': ['blessed_extension'],
+      'channel': 'beta',
+      'alias': 'feature_beta'
+    }]);
+    feature = compiler._features.get('feature_alpha')
+    self.assertTrue(feature)
+    self._hasError(feature, 'Error parsing feature "feature_alpha" at key ' +
+                            '"alias": Key can be set at most once per feature.')
+
+  def testAliasReferenceInComplexFeature(self):
+    compiler = self._createTestFeatureCompiler('APIFeature')
+    compiler._CompileFeature('feature_alpha', [{

[Devlin, 2016/11/21 16:55:53]

I think instead of this approach, it would be a bit cleaner to move the Load()
call out of Compile(), and then just set _json here.  e.g.

compiler._json = ({
    'feature_alpha': [{
      ...
    }]})
compiler.Compile()

[tbarzic, 2016/11/21 23:49:48]

Done.

+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'alias': 'feature_beta'
+    }, {
+      'contexts': ['blessed_extension'],
+      'channel': 'beta',
+    }]);
+    compiler._CompileFeature('feature_beta', {
+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'source': 'feature_alpha'
+    });
+
+    feature = compiler._features.get('feature_alpha')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+    feature.ValidateFeatureReferences(compiler._features)
+    self.assertFalse(feature.GetErrors())
+
+    feature = compiler._features.get('feature_beta')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+    feature.ValidateFeatureReferences(compiler._features)
+    self.assertFalse(feature.GetErrors())
+
+
+  def testAliasMissingReferenceInComplexFeature(self):
+    compiler = self._createTestFeatureCompiler('APIFeature')
+    compiler._CompileFeature('feature_alpha', [{
+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'alias': 'feature_beta'
+    }, {
+      'contexts': ['blessed_extension'],
+      'channel': 'beta',
+    }]);
+
+    feature = compiler._features.get('feature_alpha')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+    feature.ValidateFeatureReferences(compiler._features)
+    self._hasError(feature, 'Error parsing feature "feature_alpha" at key ' +
+                            '"alias": feature_beta is not a feature.')
+
+  def testAliasReferenceMissingSourceInComplexFeature(self):
+    compiler = self._createTestFeatureCompiler('APIFeature')
+    compiler._CompileFeature('feature_alpha', {
+      'contexts': ['blessed_extension'],
+      'channel': 'beta',
+    });
+    compiler._CompileFeature('feature_beta', {
+      'channel': 'beta',
+      'contexts': ['blessed_extension'],
+      'alias': 'feature_alpha'
+    });
+
+    feature = compiler._features.get('feature_alpha')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+    feature.ValidateFeatureReferences(compiler._features)
+    self.assertFalse(feature.GetErrors())
+
+    feature = compiler._features.get('feature_beta')
+    self.assertTrue(feature)
+    self.assertFalse(feature.GetErrors())
+
+    feature.ValidateFeatureReferences(compiler._features)
+    self._hasError(feature, 'Error parsing feature "feature_beta" at key ' +
+                            '"alias": Referenced feature ("feature_alpha") ' +
+                            'should have "source" set to "feature_beta".')
 
 if __name__ == '__main__':
   unittest.main()