Inline docs render properly in extensions doc server.

chrome/common/extensions/docs/server2/api_data_source_test.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.
 
 import json
 import os
 import sys
 import unittest
 
 from api_data_source import (APIDataSource,
                              _JSCModel,
                              _FormatValue,
                              _RemoveNoDocs)
 from compiled_file_system import CompiledFileSystem
 from file_system import FileNotFoundError
 from local_file_system import LocalFileSystem
 from object_store_creator import ObjectStoreCreator
 from reference_resolver import ReferenceResolver
+import third_party.json_schema_compiler.idl_schema as idl_schema
+import third_party.json_schema_compiler.idl_parser as idl_parser
 import third_party.json_schema_compiler.model as model
 
 def _MakeLink(href, text):
   return '<a href="%s">%s</a>' % (href, text)
 
 def _GetType(dict_, name):
   for type_ in dict_['types']:
     if type_['name'] == name:
       return type_
 
@@ skipping 11 matching lines @@
   def get(self, key):
     if key not in self._json:
       raise FileNotFoundError(key)
     return self._json[key]
 
   def GetAllNames(self):
     return self._json.keys()
 
 class APIDataSourceTest(unittest.TestCase):
   def setUp(self):
-    self._base_path = os.path.join(sys.path[0], 'test_data', 'test_json')
+    self._base_path = os.path.join(sys.path[0], 'test_data')
 
-  def _ReadLocalFile(self, filename):
-    with open(os.path.join(self._base_path, filename), 'r') as f:
+  def _ReadLocalFile(self, filename, test_dir='test_json'):
+    with open(os.path.join(self._base_path, test_dir, filename), 'r') as f:
       return f.read()
 
   def _CreateRefResolver(self, filename):
     data_source = FakeAPIAndListDataSource(
         self._LoadJSON(filename))
     return ReferenceResolver.Factory(data_source,
                                      data_source,
                                      ObjectStoreCreator.Factory()).Create()
 
   def _LoadJSON(self, filename):
@@ skipping 40 matching lines @@
     self.assertEquals(
         '%s != %s' % (_MakeLink('other.html#type-type2', 'other.type2'),
                       _MakeLink('ref_test.html#type-type2', 'type2')),
         _GetType(dict_, 'type3')['description'])
 
   def testRemoveNoDocs(self):
     d = self._LoadJSON('nodoc_test.json')
     _RemoveNoDocs(d)
     self.assertEqual(self._LoadJSON('expected_nodoc.json'), d)
 
+  def testInlineDocs(self):
+    raw_idl = self._ReadLocalFile('inline.idl', test_dir='test_idl')
+    idl = idl_parser.IDLParser().ParseData(raw_idl)
+
+    jsc = _JSCModel(
+      idl_schema.IDLSchema(idl).process()[0],
+      None, True).ToDict()
+
+    try:
+      # Make sure that inlining worked by attempting to access the inner objects
+      # inline.
+      self.assertNotEqual(
+        jsc['functions'][0]['parameters'][0].get('enum_values'),
+        None)
+      self.assertNotEqual(jsc['functions'][2]['parameters'][0].get(
+        'properties')[3].get('enum_values'),
+        None)
+    except KeyError:
+      self.assertEqual(True, False);

[not at google - send to devlin, 2013/04/24 19:36:11]

Throwing an error will fail the test anyway...

[jshumway, 2013/04/25 00:06:58]

not really sure what I was thinking there, fixed.

+

[not at google - send to devlin, 2013/04/24 19:36:11]

I think it would be more valuable to test a JSON structure then assert that
inlining its docs is what you expect. Like with the testRemoveNoDocs method.

IDL is hard to test since it's not clearly defined what the JSON output should
look like, so you're forced to do vague testing like here, which isn't that
valuable. Hard to see where it goes wrong, won't catch all errors, etc.

[jshumway, 2013/04/25 00:06:58]

I have made it so

 if __name__ == '__main__':
   unittest.main()