gcloud 0.0.7 → 0.1.0

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/utils_test.py

@@ -1,193 +0,0 @@
-"""Unit tests for the utils module."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import unittest
-
-from gcutil import mock_api
-from gcutil import utils
-
-
-class FlattenListTests(unittest.TestCase):
-  """Tests for utils.FlattenList."""
-  test_cases = (
-      ([[1], [2], [3]], [1, 2, 3]),
-      ([[1, 2, 3], [4, 5], [6]], [1, 2, 3, 4, 5, 6]),
-      ([['a'], ['    b '], ['c       ']], ['a', '    b ', 'c       ']),
-      )
-
-  def testFlattenList(self):
-    for arg, expected in self.test_cases:
-      self.assertEqual(utils.FlattenList(arg), expected)
-
-
-class GlobsToFilterTests(unittest.TestCase):
-  """Tests for utils.RegexesToFilterExpression."""
-  test_cases = (
-      (None, None),
-      ([], None),
-      (['instance-1'], 'name eq instance-1'),
-      (['instance-1 instance-2'], 'name eq instance-1|instance-2'),
-      (['instance-1', 'i.*'], 'name eq instance-1|i.*'),
-      (['a', 'b', 'c'], 'name eq a|b|c'),
-      (['a          b c'], 'name eq a|b|c'),
-      (['a          b c', 'd     e    f'], 'name eq a|b|c|d|e|f'),
-      (['instance-[0-9]+'], 'name eq instance-[0-9]+'),
-      (['a-[0-9]+', 'b-[0-9]+'], 'name eq a-[0-9]+|b-[0-9]+'),
-      (['  a-[0-9]+     b-[0-9]+ '], 'name eq a-[0-9]+|b-[0-9]+'),
-      )
-
-  def testRegexesToFilterExpression(self):
-    for arg, expected in self.test_cases:
-      self.assertEqual(utils.RegexesToFilterExpression(arg), expected)
-
-
-class ProtocolPortsTests(unittest.TestCase):
-
-  def testParseProtocolFailures(self):
-    failure_cases = (
-        None, '', 'foo'
-        )
-    for failure_case in failure_cases:
-      self.assertRaises(ValueError, utils.ParseProtocol, failure_case)
-
-  def testParseProtocolSuccesses(self):
-    test_cases = (
-        (6, 6),
-        ('6', 6),
-        ('tcp', 6),
-        ('udp', 17)
-        )
-    for arg, expected in test_cases:
-      self.assertEqual(utils.ParseProtocol(arg), expected)
-
-  def testReplacePortNamesFailures(self):
-    failure_cases = (
-        None, 22, '', 'foo', 'foo-bar', '24-42-2442'
-        )
-    for failure_case in failure_cases:
-      self.assertRaises(ValueError, utils.ReplacePortNames, failure_case)
-
-  def testReplacePortNameSuccesses(self):
-    test_cases = (
-        ('ssh', '22'),
-        ('22', '22'),
-        ('ssh-http', '22-80'),
-        ('22-http', '22-80'),
-        ('ssh-80', '22-80'),
-        ('22-80', '22-80')
-        )
-    for arg, expected in test_cases:
-      self.assertEqual(utils.ReplacePortNames(arg), expected)
-
-
-class SingularizeTests(unittest.TestCase):
-  """Tests for utils.Singularize."""
-
-  test_cases = (
-      ('instances', 'instance'),
-      ('disks', 'disk'),
-      ('firewalls', 'firewall'),
-      ('snapshots', 'snapshot'),
-      ('operations', 'operation'),
-      ('images', 'image'),
-      ('kernels', 'kernel'),
-      ('networks', 'network'),
-      ('machineTypes', 'machineType'),
-      ('backendGroups', 'backendGroup'),
-      ('publicEndpoints', 'publicEndpoint'),
-      )
-
-  def testSingularize(self):
-    for arg, expected in self.test_cases:
-      self.assertEqual(utils.Singularize(arg), expected)
-      self.assertEqual(utils.Singularize(expected), expected)
-
-
-class AllTests(unittest.TestCase):
-  """Tests for utils.All."""
-
-  def setUp(self):
-    self._page = 0
-
-  def testArgumentPlumbing(self):
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      self.assertEqual(project, 'my-project')
-      self.assertEqual(maxResults, 651)
-      self.assertEqual(filter, 'name eq my-instance')
-      self.assertEqual(pageToken, None)
-      return mock_api.MockRequest(
-          {'kind': 'numbers', 'items': [1, 2, 3]})
-
-    utils.All(mockFunc, 'my-project',
-              max_results=651,
-              filter='name eq my-instance')
-
-  def testWithZones(self):
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None,
-                 zone=None):
-      self.assertEqual('some-zone', zone)
-      return mock_api.MockRequest(
-          {'kind': 'numbers', 'items': [1, 2, 3]})
-
-    utils.All(mockFunc, 'my-project', zone='some-zone')
-
-  def testWithEmptyResponse(self):
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      return mock_api.MockRequest({'kind': 'numbers', 'items': []})
-
-    self.assertEqual(utils.All(mockFunc, 'my-project'),
-                     {'kind': 'numbers', 'items': []})
-
-  def testWithNoPaging(self):
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      return mock_api.MockRequest({'kind': 'numbers', 'items': [1, 2, 3]})
-
-    self.assertEqual(utils.All(mockFunc, 'my-project'),
-                     {'kind': 'numbers', 'items': [1, 2, 3]})
-
-  def testWithPaging(self):
-    responses = [
-        mock_api.MockRequest(
-            {'kind': 'numbers', 'items': [1, 2, 3], 'nextPageToken': 'abc'}),
-        mock_api.MockRequest(
-            {'kind': 'numbers', 'items': [4, 5, 6]})]
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      self._page += 1
-      return responses[self._page - 1]
-
-    self.assertEqual(utils.All(mockFunc, 'my-project'),
-                     {'kind': 'numbers', 'items': [1, 2, 3, 4, 5, 6]})
-
-  def testWithNoPagingAndSlicing(self):
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      return mock_api.MockRequest({'kind': 'numbers', 'items': [1, 2, 3]})
-
-    self.assertEqual(utils.All(mockFunc, 'my-project', max_results=2),
-                     {'kind': 'numbers', 'items': [1, 2]})
-
-  def testWithPagingAndSlicing(self):
-    responses = [
-        mock_api.MockRequest(
-            {'kind': 'numbers', 'items': [1, 2, 3], 'nextPageToken': 'abc'}),
-        mock_api.MockRequest(
-            {'kind': 'numbers', 'items': [4, 5, 6]})]
-
-    def mockFunc(project=None, maxResults=None, filter=None, pageToken=None):
-      self._page += 1
-      return responses[self._page - 1]
-
-    self.assertEqual(utils.All(mockFunc, 'my-project', max_results=5),
-                     {'kind': 'numbers', 'items': [1, 2, 3, 4, 5]})
-
-
-if __name__ == '__main__':
-  unittest.main()

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/version_checker.py

@@ -1,246 +0,0 @@
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""A module can check for new versions of gcutil.
-
-A JSON file located at VERSION_INFO_URL contains the version number of
-the latest version of gcutil.
-"""
-
-
-
-import json
-import logging
-import os
-import time
-
-import httplib2
-
-import gflags as flags
-
-from gcutil import gcutil_logging
-from gcutil import version
-
-LOGGER = gcutil_logging.LOGGER
-VERSION_INFO_URL = 'http://dl.google.com/compute/latest-version.json'
-VERSION_CACHE_FILE = '~/.gcutil.version'
-SETUP_DOC_URL = 'https://developers.google.com/compute/docs/gcutil'
-TIMEOUT_IN_SEC = 1
-
-# The minimum amount of time that can pass between visits to
-# VERSION_INFO_URL to grab the latest version string.
-CACHE_TTL_SEC = 24 * 60 * 60
-
-FLAGS = flags.FLAGS
-
-flags.DEFINE_boolean('check_for_new_version',
-                     True,
-                     'Perform an update check.')
-
-
-class VersionChecker(object):
-  """A class that encapsulates the logic for performing version checks."""
-
-  def __init__(
-      self,
-      perform_check=FLAGS.check_for_new_version,
-      cache_path=VERSION_CACHE_FILE,
-      cache_ttl_sec=CACHE_TTL_SEC,
-      current_version=version.__version__):
-    """Constructs a new VersionChecker.
-
-    Args:
-      perform_check: Skips the check if False.
-      cache_path: The path to a file that caches the results of
-        fetching VERSION_INFO_URL.
-      cache_ttl_sec: The maximum amount of time the cache is considered
-        valid.
-    """
-    self._perform_check = perform_check
-    self._cache_path = os.path.expanduser(cache_path)
-    self._cache_ttl_sec = cache_ttl_sec
-    self._current_version = current_version
-
-  @staticmethod
-  def _IsCacheMalformed(cache):
-    """Returns True if the given cache is not in its expected form."""
-    if ('last_check' not in cache or
-        'current_version' not in cache or
-        'last_checked_version' not in cache):
-      return True
-
-    if not isinstance(cache['last_check'], float):
-      return True
-
-    try:
-      VersionChecker._ParseVersionString(cache['current_version'])
-      VersionChecker._ParseVersionString(cache['last_checked_version'])
-    except BaseException:
-      return True
-
-    return False
-
-  def _IsCacheStale(self, cache, current_time=None):
-    """Returns True if the cache is stale."""
-    if VersionChecker._IsCacheMalformed(cache):
-      LOGGER.debug('Encountered malformed or empty cache: %s', cache)
-      return True
-
-    # If the gcutil version has changed since the last cache write, then
-    # the cache is stale.
-    if cache['current_version'] != self._current_version:
-      return True
-
-    current_time = time.time() if current_time is None else current_time
-
-    # If the cache is old, then it's stale.
-    if cache['last_check'] + self._cache_ttl_sec <= current_time:
-      return True
-
-    # If for some reason the current time is less than the last time
-    # the cache was written to (e.g., the user changed his or her
-    # system time), then the safest thing to do is to assume the cache
-    # is stale.
-    if cache['last_check'] > current_time:
-      return True
-
-    return False
-
-  @staticmethod
-  def _ParseVersionString(version_string):
-    """Converts a version string into a tuple of its components.
-
-    For example, '1.2.0' -> (1, 2, 0).
-
-    Args:
-      version_string: The input.
-
-    Raises:
-      ValueError: If any of the version components are not integers.
-
-    Returns:
-      A tuple of the version components.
-    """
-    try:
-      return tuple([int(i) for i in version_string.split('.')])
-    except ValueError as e:
-      raise ValueError('Could not parse version string %s: %s' %
-                       (version_string, e))
-
-  @staticmethod
-  def _CompareVersions(left, right):
-    """Returns True if the left version is less than the right version."""
-    return (VersionChecker._ParseVersionString(left) <
-            VersionChecker._ParseVersionString(right))
-
-  def _UpdateCache(self, cache, http=None, current_time=None):
-    """Fetches the version info and updates the given cache dict.
-
-    Args:
-      cache: A dict representing the contents of the cache.
-      http: An httplib2.Http object. This is used for testing.
-      current_time: The current time since the Epoch, in seconds.
-        This is also used for testing.
-
-    Raises:
-      ValueError: If the response code is not 200.
-    """
-    http = http or httplib2.Http(timeout=TIMEOUT_IN_SEC)
-    response, content = http.request(
-        VERSION_INFO_URL, headers={'Cache-Control': 'no-cache'})
-    LOGGER.debug('Version check response: %s', response)
-    LOGGER.debug('Version check payload: %s', content)
-    if response.status != 200:
-      raise ValueError('Received response code %s while fetching %s.',
-                       response.status, VERSION_INFO_URL)
-
-    latest_version = json.loads(content)['version']
-    cache['current_version'] = self._current_version
-    cache['last_checked_version'] = latest_version
-    cache['last_check'] = current_time or time.time()
-
-  def _ReadCache(self):
-    """Reads the contents of the version cache file.
-
-    Returns:
-      A dict that corresponds to the JSON stored in the cache file.
-      Returns an empty dict if the cache file does not exist or if
-      there is a problem reading/parsing the cache.
-    """
-    if not os.path.exists(self._cache_path):
-      return {}
-
-    try:
-      with open(self._cache_path) as f:
-        return json.load(f)
-    except BaseException as e:
-      LOGGER.debug('Reading %s failed: %s', self._cache_path, e)
-
-    return {}
-
-  def _WriteToCache(self, cache):
-    """JSON-serializes the given dict and writes it to the cache."""
-    with open(self._cache_path, 'w') as f:
-      json.dump(cache, f)
-
-  def _NewVersionExists(self):
-    """Returns True if a new gcutil version exists."""
-    cache = self._ReadCache()
-    if self._IsCacheStale(cache):
-      LOGGER.debug('%s is stale. Consulting %s for latest version info...',
-                    self._cache_path, VERSION_INFO_URL)
-      self._UpdateCache(cache)
-      self._WriteToCache(cache)
-    else:
-      LOGGER.debug('Consulting %s for latest version info...', self._cache_path)
-
-    latest_version = cache['last_checked_version']
-    ret = self._CompareVersions(self._current_version, latest_version)
-    return ret
-
-  def CheckForNewVersion(self):
-    """Performs the actual check for a new version.
-
-    This method may either consult the cache or the web, depending on
-    the cache's age.
-
-    The side-effect of this message is a WARN log that tells the user
-    of an old version.
-
-    Returns:
-      True if version checking was requested and a new version is
-      available.
-    """
-    if not self._perform_check:
-      logging.debug('Skipping version check...')
-      return
-
-    LOGGER.debug('Performing version check...')
-
-    try:
-      if self._NewVersionExists():
-        LOGGER.warning(
-            'There is a new version of gcutil available. Go to: %s',
-            SETUP_DOC_URL)
-        LOGGER.warning(
-            'Your version of gcutil is %s, the latest version is %s.',
-            version.__version__, latest_version)
-      else:
-        LOGGER.debug('gcutil is up-to-date.')
-
-    # So much can go wrong with this code that it's unreasonable to
-    # add error handling everywhere hence the "catch-all" exception
-    # handling.
-    except BaseException as e:
-      LOGGER.debug('Version checking failed: %s', e)

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/version_checker_test.py

@@ -1,271 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Unit tests for the version_checker module."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import json
-import os
-import tempfile
-
-import httplib2
-
-import unittest
-from gcutil import version_checker
-
-
-class VersionCheckerTests(unittest.TestCase):
-
-  class MockHttp(httplib2.Http):
-    """A mock for httplib2.Http that always times out on requests."""
-
-    def request(self, *unused_args, **unused_kwargs):
-      return (httplib2.Response({
-          'status': '200',
-          'content-length': '81',
-          'last-modified': 'Thu, 28 Jun 2012 21:35:00 GMT',
-          'date': 'Fri, 14 Sep 2012 21:59:51 GMT',
-          'content-type': 'application/json'}),
-              '{\n "version": "1.3.0",\n "package_name": "gcutil-1.3.0"\n}\n')
-
-  def testReadCacheWithNonExistentCacheFile(self):
-    vc = version_checker.VersionChecker(cache_path='non-existent-file')
-    self.assertEqual(vc._ReadCache(), {})
-
-  def testReadCacheWithMalformedJson(self):
-    malformed_caches = (
-        'MALFORMED JSON',
-        '{ "last_checked_version": "1.2", "last_check": 3000.0, }',
-        '{ "last_checked_version": "1.2", "last_check": 3000.0 }}',
-        '{ "last_checked_version": "1.2", "last_check": 3000.0 }bad characters')
-
-    for malformed_cache in malformed_caches:
-      _, bad_cache_file = tempfile.mkstemp()
-      try:
-        with open(bad_cache_file, 'w') as f:
-          f.write(malformed_cache)
-
-        vc = version_checker.VersionChecker(cache_path=bad_cache_file)
-        self.assertEqual(vc._ReadCache(), {})
-      finally:
-        os.remove(bad_cache_file)
-
-  def testReadCacheWithGoodCache(self):
-    _, cache_file = tempfile.mkstemp()
-    try:
-      with open(cache_file, 'w') as f:
-        f.write('{ "last_checked_version": "1.2", "last_check": 3000.0 }')
-
-      vc = version_checker.VersionChecker(cache_path=cache_file)
-      self.assertEqual(vc._ReadCache(), {'last_checked_version': '1.2',
-                                         'last_check': 3000})
-    finally:
-      os.remove(cache_file)
-
-  def testWriteToCache(self):
-    _, cache_file = tempfile.mkstemp()
-    try:
-      cache = {'last_checked_version': '1.2', 'last_check': 3000}
-      vc = version_checker.VersionChecker(cache_path=cache_file)
-      vc._WriteToCache(cache)
-
-      with open(cache_file) as f:
-        self.assertEqual(json.load(f), cache)
-    finally:
-      os.remove(cache_file)
-
-  def testUpdateCache(self):
-    vc = version_checker.VersionChecker(
-        cache_ttl_sec=20, current_version='1.2.0')
-    cache = {}
-    vc._UpdateCache(
-        cache, http=VersionCheckerTests.MockHttp(), current_time=123456.7)
-    self.assertEqual(cache['current_version'], '1.2.0')
-    self.assertEqual(cache['last_checked_version'], '1.3.0')
-    self.assertEqual(cache['last_check'], 123456.7)
-
-  def testIsCacheMalformed(self):
-    malformed_caches = (
-        {},
-        {'last_checked_version': 'x', 'last_check': 3000.0,
-         'current_version': 'y'},
-        {'last_checked_version': '1...2', 'last_check': 3000.0,
-         'current_version': '1.2'},
-        {'last_checked_version': '1.2', 'last_check': 3000,
-         'current_version': '1.2.0'},
-        {'last_checked_version': '1.2', 'current_version': '1.2.0'},
-        {'last_checked_version': '1.2.x', 'last_check': 3000,
-             'current_version': '1.2.0'})
-    for cache in malformed_caches:
-      self.assertTrue(version_checker.VersionChecker._IsCacheMalformed(cache))
-
-    good_caches = (
-        {'last_checked_version': '1.3.0', 'last_check': 3000.0,
-         'current_version': '1.2.0'},
-        {'last_checked_version': '1.3.0', 'last_check': 3000.0,
-         'current_version': '1.2.0',
-         'last_check_time': '2012-09-17T18:03:48.792579+00:00',
-         'latest_version': '1.1.20120628.1214'})
-    for cache in good_caches:
-      self.assertFalse(version_checker.VersionChecker._IsCacheMalformed(cache))
-
-  def testIsCacheStale(self):
-    vc = version_checker.VersionChecker(
-        cache_ttl_sec=20, current_version='1.2.0')
-    cache = {'last_checked_version': '1.2', 'last_check': 3000.0,
-             'current_version': '1.2.0'}
-
-    self.assertTrue(vc._IsCacheStale(cache, current_time=1))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
-    self.assertFalse(vc._IsCacheStale(cache, current_time=3000))
-    self.assertFalse(vc._IsCacheStale(cache, current_time=3005))
-    self.assertFalse(vc._IsCacheStale(cache, current_time=3010))
-    self.assertFalse(vc._IsCacheStale(cache, current_time=3019))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
-
-    self.assertTrue(vc._IsCacheStale({}, current_time=1))
-    self.assertTrue(vc._IsCacheStale({}, current_time=2000))
-    self.assertTrue(vc._IsCacheStale({}, current_time=2999))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3000))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3005))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3010))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3019))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3020))
-    self.assertTrue(vc._IsCacheStale({}, current_time=3021))
-    self.assertTrue(vc._IsCacheStale({}, current_time=4000))
-    self.assertTrue(vc._IsCacheStale({}, current_time=398457398))
-
-  def testIsCacheStaleWithMalformedCache(self):
-    vc = version_checker.VersionChecker(
-        cache_ttl_sec=20, current_version='1.2.0')
-    malformed_caches = (
-        {'last_checked_version': '1.2', 'last_check': 3000,
-         'current_version': '1.2.0'},
-        {'last_checked_version': '1.2', 'current_version': '1.2.0'},
-        {'last_checked_version': '1.2.x', 'last_check': 3000,
-             'current_version': '1.2.0'})
-
-    for cache in malformed_caches:
-      self.assertTrue(vc._IsCacheStale(cache, current_time=1))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3000))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3005))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3010))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3019))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
-      self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
-
-  def testIsCacheStaleWithUpgradedVersion(self):
-    vc = version_checker.VersionChecker(
-        cache_ttl_sec=20, current_version='1.3.0')
-    cache = {'last_checked_version': '1.3.0', 'last_check': 3000.0,
-             'current_version': '1.2.0'}
-
-    self.assertTrue(vc._IsCacheStale(cache, current_time=1))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3000))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3005))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3010))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3019))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
-    self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
-
-  def testParseVersionString(self):
-    parse_fn = version_checker.VersionChecker._ParseVersionString
-    self.assertEqual(parse_fn('1'), (1,))
-    self.assertEqual(parse_fn('1.2'), (1, 2))
-    self.assertEqual(parse_fn('1.2.0'), (1, 2, 0))
-    self.assertEqual(parse_fn('0.1.0'), (0, 1, 0))
-    self.assertEqual(parse_fn('12.13.14'), (12, 13, 14))
-
-  def testCompareVersions(self):
-    compare_fn = version_checker.VersionChecker._CompareVersions
-    self.assertTrue(compare_fn('0', '1.2'))
-    self.assertTrue(compare_fn('1.2', '1.3'))
-    self.assertTrue(compare_fn('1.2', '1.2.1'))
-    self.assertTrue(compare_fn('1.2.0', '1.2.1'))
-    self.assertTrue(compare_fn('1.2.0', '1.2.13'))
-    self.assertTrue(compare_fn('1.2.0', '1.3'))
-    self.assertFalse(compare_fn('1.3', '1.3'))
-    self.assertFalse(compare_fn('1.2.2', '1.2.0'))
-    self.assertFalse(compare_fn('1.1', '1.0'))
-
-  def testNewVersionExistsWithNonStaleCache(self):
-
-    def MockReadCache():
-      return {'last_checked_version': '1.3.0', 'last_check': 3000.0,
-             'current_version': '1.2.0'}
-
-    def MockIsCacheStale(cache):
-      return False
-
-    vc = version_checker.VersionChecker(current_version='1.2.0')
-    vc._ReadCache = MockReadCache
-    vc._IsCacheStale = MockIsCacheStale
-    self.assertTrue(vc._NewVersionExists())
-
-    vc = version_checker.VersionChecker(current_version='1.3.0')
-    vc._ReadCache = MockReadCache
-    vc._IsCacheStale = MockIsCacheStale
-    self.assertFalse(vc._NewVersionExists())
-
-  def testNewVersionExistsWithStaleCache(self):
-
-    def MockIsCacheStale(cache):
-      return True
-
-    def MockUpdateCache(cache):
-      cache['last_checked_version'] = '1.3.0'
-
-    _, cache_file = tempfile.mkstemp()
-    try:
-      with open(cache_file, 'w') as f:
-        f.write('{ "last_checked_version": "1.2.0", "last_check": 3000.0,'
-                '   "current_version": "1.2.0"}')
-
-        vc = version_checker.VersionChecker(
-            cache_path=cache_file, current_version='1.2.0')
-        vc._IsCacheStale = MockIsCacheStale
-        vc._UpdateCache = MockUpdateCache
-        self.assertTrue(vc._NewVersionExists())
-        self.assertEqual(vc._ReadCache()['last_checked_version'], '1.3.0')
-
-        def MockUpdateCache2(cache):
-          cache['last_checked_version'] = '1.2.0'
-
-        vc._UpdateCache = MockUpdateCache2
-        self.assertFalse(vc._NewVersionExists())
-        self.assertEqual(vc._ReadCache()['last_checked_version'], '1.2.0')
-    finally:
-      os.remove(cache_file)
-
-
-if __name__ == '__main__':
-  unittest.main()