docserver: Adds "API scheduled for Chrome version..." text to dev and beta APIs

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 (_JSCModel,
                              _FormatValue,
                              _GetEventByNameFromEvents)
+from availability_finder import AvailabilityInfo
 from branch_utility import ChannelInfo
 from extensions_paths import CHROME_EXTENSIONS
 from fake_host_file_system_provider import FakeHostFileSystemProvider
 from features_bundle import FeaturesBundle
 from file_system import FileNotFoundError
 from future import Future
 from object_store_creator import ObjectStoreCreator
 from server_instance import ServerInstance
 from test_data.canned_data import (CANNED_API_FILE_SYSTEM_DATA, CANNED_BRANCHES)
 from test_data.api_data_source.canned_trunk_fs import CANNED_TRUNK_FS_DATA
 from test_file_system import TestFileSystem
 from test_util import Server2Path
 from third_party.json_schema_compiler.memoize import memoize
 
 
 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_
 
 
 class _FakeAvailabilityFinder(object):
 
   def GetApiAvailability(self, version):
-    return ChannelInfo('stable', '396', 5)
+    return AvailabilityInfo(ChannelInfo('stable', '396', 5))
+
+
+class _FakeScheduledAvailabilityFinder(object):
+
+  def GetApiAvailability(self, version):
+    return AvailabilityInfo(ChannelInfo('dev', '1500', 28), 28)

[not at google - send to devlin, 2014/04/29 00:19:43]

use a different 'version' and 'scheduled' just to be safe (maybe the numbers
have been mixed up or something).

[danielj41, 2014/04/30 21:07:11]

Done.

 
 
 class _FakeTemplateCache(object):
 
   def GetFromFile(self, key):
     return Future(value='handlebar %s' % key)
 
 
 class APIDataSourceTest(unittest.TestCase):
 
@@ skipping 49 matching lines @@
                       None).ToDict()
     self.assertEquals(expected_json, dict_)
 
   def testFormatValue(self):
     self.assertEquals('1,234,567', _FormatValue(1234567))
     self.assertEquals('67', _FormatValue(67))
     self.assertEquals('234,567', _FormatValue(234567))
 
   def testGetApiAvailability(self):
     api_availabilities = {
-      'bluetooth': ChannelInfo('dev', CANNED_BRANCHES[28], 28),
-      'contextMenus': ChannelInfo('trunk', CANNED_BRANCHES['trunk'], 'trunk'),
-      'jsonStableAPI': ChannelInfo('stable', CANNED_BRANCHES[20], 20),
-      'idle': ChannelInfo('stable', CANNED_BRANCHES[5], 5),
-      'input.ime': ChannelInfo('stable', CANNED_BRANCHES[18], 18),
-      'tabs': ChannelInfo('stable', CANNED_BRANCHES[18], 18)
+      'bluetooth': AvailabilityInfo(
+          ChannelInfo('dev', CANNED_BRANCHES[28], 28)),
+      'contextMenus': AvailabilityInfo(
+          ChannelInfo('trunk', CANNED_BRANCHES['trunk'], 'trunk')),
+      'jsonStableAPI': AvailabilityInfo(
+          ChannelInfo('stable', CANNED_BRANCHES[20], 20)),
+      'idle': AvailabilityInfo(
+          ChannelInfo('stable', CANNED_BRANCHES[5], 5)),
+      'input.ime': AvailabilityInfo(
+          ChannelInfo('stable', CANNED_BRANCHES[18], 18)),
+      'tabs': AvailabilityInfo(
+          ChannelInfo('stable', CANNED_BRANCHES[18], 18))
     }
     for api_name, availability in api_availabilities.iteritems():
       model = _JSCModel(self._avail_api_models.GetModel(api_name).Get(),
                         self._avail_finder,
                         self._avail_json_cache,
                         _FakeTemplateCache(),
                         self._features_bundle,
                         None)
       self.assertEquals(availability, model._GetApiAvailability())
 
   def testGetIntroList(self):
     model = _JSCModel(self._api_models.GetModel('tester').Get(),
                       _FakeAvailabilityFinder(),
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       None)
     expected_list = [
       { 'title': 'Description',
         'content': [
           { 'text': 'a test api' }
         ]
       },
       { 'title': 'Availability',
         'content': [
           { 'partial': 'handlebar chrome/common/extensions/docs/' +
                        'templates/private/intro_tables/stable_message.html',
-            'version': 5
+            'version': 5,
+            'scheduled': None
           }
         ]
       },
       { 'title': 'Permissions',
         'content': [
           { 'class': 'override',
             'text': '"tester"'
           },
           { 'text': 'is an API for testing things.' }
         ]
       },
       { 'title': 'Manifest',
         'content': [
           { 'class': 'code',
             'text': '"tester": {...}'
           }
         ]
       },
       { 'title': 'Learn More',
         'content': [
           { 'link': 'https://tester.test.com/welcome.html',
             'text': 'Welcome!'
           }
         ]
       }
     ]
     self.assertEquals(model._GetIntroTableList(), expected_list)
 
+    # Tests the same data with a scheduled availability.
+    model = _JSCModel(self._api_models.GetModel('tester').Get(),
+                      _FakeScheduledAvailabilityFinder(),
+                      self._json_cache,
+                      _FakeTemplateCache(),
+                      self._features_bundle,
+                      None)
+    expected_list[1] = {
+      'title': 'Availability',
+      'content': [
+          { 'partial': 'handlebar chrome/common/extensions/docs/' +
+                       'templates/private/intro_tables/dev_message.html',
+          'version': 28,
+          'scheduled': 28
+        }
+      ]
+    }
+    self.assertEquals(model._GetIntroTableList(), expected_list)
+
   def testGetEventByNameFromEvents(self):
     events = {}
     # Missing 'types' completely.
     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 
     events['types'] = []
     # No type 'Event' defined.
     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 
     events['types'].append({ 'name': 'Event',
@@ skipping 29 matching lines @@
     # Check that the second event has addListener defined.
     self.assertEquals('noRules', dict_['events'][1]['name'])
     self.assertEquals('add_rules_tester', dict_['name'])
     self.assertEquals('noRules', dict_['events'][1]['name'])
     self.assertEquals('callback',
                       dict_['events'][0]['byName']['addListener'][
                           'parameters'][0]['name'])
 
 if __name__ == '__main__':
   unittest.main()