Docserver: Implement ContentProvider.GetVersion.

chrome/common/extensions/docs/server2/content_provider_test.py

 #!/usr/bin/env python
 # Copyright 2013 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.
 
 from cStringIO import StringIO
 import json
 import unittest
 from zipfile import ZipFile
 
@@ skipping 58 matching lines @@
   'noextension': 'noextension content',
   'run.js': 'run.js content',
   'site.css': 'site.css content',
   'storage.html': 'storage.html content',
   'markdown.md': '\n'.join(text[0] for text in _MARKDOWN_CONTENT)
 }
 
 
 class ContentProviderUnittest(unittest.TestCase):
   def setUp(self):
+    self._test_file_system = TestFileSystem(_TEST_DATA)
     self._content_provider = self._CreateContentProvider()
 
   def _CreateContentProvider(self, supports_zip=False):
     object_store_creator = ObjectStoreCreator.ForTest()
-    test_file_system = TestFileSystem(_TEST_DATA)
     return ContentProvider(
         'foo',
         CompiledFileSystem.Factory(object_store_creator),
-        test_file_system,
+        self._test_file_system,
         object_store_creator,
         default_extensions=('.html', '.md'),
         # TODO(kalman): Test supports_templates=False.
         supports_templates=True,
         supports_zip=supports_zip)
 
   def _assertContent(self, content, content_type, content_and_type):
     # Assert type so that str is differentiated from unicode.
     self.assertEqual(type(content), type(content_and_type.content))
     self.assertEqual(content, content_and_type.content)
     self.assertEqual(content_type, content_and_type.content_type)
 
-  def _assertTemplateContent(self, content, path):
+  def _assertTemplateContent(self, content, path, version):
     content_and_type = self._content_provider.GetContentAndType(path).Get()
     self.assertEqual(Handlebar, type(content_and_type.content))
     content_and_type.content = content_and_type.content.source
     self._assertContent(content, 'text/html', content_and_type)
+    self.assertEqual(version, self._content_provider.GetVersion(path).Get())
 
-  def _assertMarkdownContent(self, content, path):
+  def _assertMarkdownContent(self, content, path, version):
     content_and_type = self._content_provider.GetContentAndType(path).Get()
     content_and_type.content = content_and_type.content.source
     self._assertContent(content, 'text/html', content_and_type)
+    self.assertEqual(version, self._content_provider.GetVersion(path).Get())
 
   def testPlainText(self):
     self._assertContent(
         u'a.txt content', 'text/plain',
         self._content_provider.GetContentAndType('dir/a.txt').Get())
     self._assertContent(
         u'd.txt content', 'text/plain',
         self._content_provider.GetContentAndType('dir/c/d.txt').Get())
     self._assertContent(
         u'read.txt content', 'text/plain',
         self._content_provider.GetContentAndType('read.txt').Get())
     self._assertContent(
         unicode(_REDIRECTS_JSON, 'utf-8'), 'application/json',
         self._content_provider.GetContentAndType('redirects.json').Get())
     self._assertContent(
         u'run.js content', 'application/javascript',
         self._content_provider.GetContentAndType('run.js').Get())
     self._assertContent(
         u'site.css content', 'text/css',
         self._content_provider.GetContentAndType('site.css').Get())
 
   def testTemplate(self):
-    self._assertTemplateContent(u'storage.html content', 'storage.html')
+    self._assertTemplateContent(u'storage.html content', 'storage.html', '0')
+    self._test_file_system.IncrementStat('storage.html')
+    self._assertTemplateContent(u'storage.html content', 'storage.html', '1')
 
   def testImage(self):
     self._assertContent(
         'img.png content', 'image/png',
         self._content_provider.GetContentAndType('img.png').Get())
 
   def testZipTopLevel(self):
     zip_content_provider = self._CreateContentProvider(supports_zip=True)
     content_and_type = zip_content_provider.GetContentAndType('dir.zip').Get()
     zipfile = ZipFile(StringIO(content_and_type.content))
@@ skipping 24 matching lines @@
     # corresponds to the canonical directory.
     zip_content_provider = self._CreateContentProvider(supports_zip=True)
     self.assertEqual(
         'dir.zip',
         zip_content_provider.GetCanonicalPath('dir.zip'))
     self.assertEqual(
         'dir.zip',
         zip_content_provider.GetCanonicalPath('diR.zip'))
 
   def testMarkdown(self):
-    self._assertMarkdownContent(
-        '\n'.join(text[1] for text in _MARKDOWN_CONTENT),
-        'markdown')
+    expected_content = '\n'.join(text[1] for text in _MARKDOWN_CONTENT)
+    self._assertMarkdownContent(expected_content, 'markdown', '0')
+    self._test_file_system.IncrementStat('markdown.md')
+    self._assertMarkdownContent(expected_content, 'markdown', '1')
 
   def testNotFound(self):
     self.assertRaises(
         FileNotFoundError,
         self._content_provider.GetContentAndType('oops').Get)
 
   def testIndexRedirect(self):
-    self._assertTemplateContent(u'index.html content', '')
-    self._assertTemplateContent(u'index.html content 1', 'dir4')
-    self._assertTemplateContent(u'dir5.html content', 'dir5')
+    self._assertTemplateContent(u'index.html content', '', '0')
+    self._assertTemplateContent(u'index.html content 1', 'dir4', '0')
+    self._assertTemplateContent(u'dir5.html content', 'dir5', '0')
     self._assertMarkdownContent(
         '\n'.join(text[1] for text in _MARKDOWN_CONTENT),
-        'dir7')
+        'dir7',
+        '0')
     self._assertContent(
         'noextension content', 'text/plain',
         self._content_provider.GetContentAndType('noextension').Get())
     self.assertRaises(
         FileNotFoundError,
         self._content_provider.GetContentAndType('dir6').Get)
 
+  def testCron(self):
+    # Not entirely sure what to test here, but get some code coverage.
+    self._content_provider.Cron().Get()
+
+
 if __name__ == '__main__':
   unittest.main()