Roll version of gsutil to 4.15.

third_party/gsutil/gslib/tests/test_naming.py

 # -*- coding: utf-8 -*-
 # Copyright 2010 Google Inc. All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
@@ skipping 21 matching lines @@
 from __future__ import absolute_import
 
 import gzip
 import os
 import StringIO
 
 from gslib import copy_helper
 from gslib.cloud_api import NotFoundException
 from gslib.cloud_api import ServiceException
 from gslib.exception import CommandException
-from gslib.exception import HashMismatchException
 from gslib.storage_url import StorageUrlFromString
 import gslib.tests.testcase as testcase
 from gslib.tests.util import ObjectToURI as suri
 from gslib.tests.util import SetBotoConfigForTest
 from gslib.util import UTF8
 
 
 def _Overwrite(fp):
   """Overwrite first byte in an open file and flush contents."""
   fp.seek(0)
   fp.write('x')
   fp.flush()
 
 
 def _Append(fp):
   """Append a byte at end of an open file and flush contents."""
   fp.seek(0, 2)
   fp.write('x')
   fp.flush()
 
 
-# TODO: Re-enable PerformsFileToObjectUpload decorator on tests in this file
+# TODO: Re-enable SequentialAndParallelTransfer decorator on tests in this file
 # once we refactor to a thread-safe mock storage service implementation.
 class GsutilNamingTests(testcase.GsUtilUnitTestCase):
   """Unit tests for gsutil naming logic."""
 
   def testGetPathBeforeFinalDir(self):
     """Tests GetPathBeforeFinalDir() (unit test)."""
     self.assertEqual(
         'gs://', copy_helper.GetPathBeforeFinalDir(StorageUrlFromString(
             'gs://bucket/')))
     self.assertEqual(
         'gs://bucket', copy_helper.GetPathBeforeFinalDir(StorageUrlFromString(
             'gs://bucket/dir/')))
     self.assertEqual(
         'gs://bucket', copy_helper.GetPathBeforeFinalDir(StorageUrlFromString(
             'gs://bucket/dir')))
     self.assertEqual(
         'gs://bucket/dir', copy_helper.GetPathBeforeFinalDir(
             StorageUrlFromString('gs://bucket/dir/obj')))
     src_dir = self.CreateTempDir()
     subdir = os.path.join(src_dir, 'subdir')
     os.mkdir(subdir)
     self.assertEqual(suri(src_dir),
                      copy_helper.GetPathBeforeFinalDir(
                          StorageUrlFromString(suri(subdir))))
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingTopLevelFileToBucket(self):
     """Tests copying one top-level file to a bucket."""
     src_file = self.CreateTempFile(file_name='f0')
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', [src_file, suri(dst_bucket_uri)])
     actual = list(self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     self.assertEqual(1, len(actual))
     self.assertEqual('f0', actual[0].root_object.name)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingMultipleFilesToBucket(self):
     """Tests copying multiple files to a bucket."""
     src_file0 = self.CreateTempFile(file_name='f0')
     src_file1 = self.CreateTempFile(file_name='f1')
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', [src_file0, src_file1, suri(dst_bucket_uri)])
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([
         suri(dst_bucket_uri, 'f0'),
         suri(dst_bucket_uri, 'f1'),
     ])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingNestedFileToBucketSubdir(self):
     """Tests copying a nested file to a bucket subdir.
 
     Tests that we correctly translate local FS-specific delimiters ('\' on
     Windows) to bucket delimiter (/).
     """
     tmpdir = self.CreateTempDir()
     subdir = os.path.join(tmpdir, 'subdir')
     os.mkdir(subdir)
     src_file = self.CreateTempFile(tmpdir=tmpdir, file_name='obj', contents='')
     dst_bucket_uri = self.CreateBucket()
     # Make an object under subdir so next copy will treat subdir as a subdir.
     self.RunCommand('cp', [src_file, suri(dst_bucket_uri, 'subdir/a')])
     self.RunCommand('cp', [src_file, suri(dst_bucket_uri, 'subdir')])
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterObjects())
     expected = set([
         suri(dst_bucket_uri, 'subdir', 'a'),
         suri(dst_bucket_uri, 'subdir', 'obj'),
     ])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingAbsolutePathDirToBucket(self):
     """Tests recursively copying absolute path directory to a bucket."""
     dst_bucket_uri = self.CreateBucket()
     src_dir_root = self.CreateTempDir(test_files=[
         'f0', 'f1', 'f2.txt', ('dir0', 'dir1', 'nested')])
     self.RunCommand('cp', ['-R', src_dir_root, suri(dst_bucket_uri)])
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     src_tmpdir = os.path.split(src_dir_root)[1]
     expected = set([
         suri(dst_bucket_uri, src_tmpdir, 'f0'),
         suri(dst_bucket_uri, src_tmpdir, 'f1'),
         suri(dst_bucket_uri, src_tmpdir, 'f2.txt'),
         suri(dst_bucket_uri, src_tmpdir, 'dir0', 'dir1', 'nested')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingRelativePathDirToBucket(self):
     """Tests recursively copying relative directory to a bucket."""
     dst_bucket_uri = self.CreateBucket()
     src_dir = self.CreateTempDir(test_files=[('dir0', 'f1')])
     self.RunCommand('cp', ['-R', 'dir0', suri(dst_bucket_uri)], cwd=src_dir)
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'dir0', 'f1')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingRelPathSubDirToBucketSubdirWithDollarFolderObj(self):
     """Tests recursively copying relative sub-directory to bucket subdir.
 
     Subdir is signified by a $folder$ object.
     """
-    # Create a $folder$ object to simulate a folder created by GCS manager (or
-    # various other tools), which gsutil understands to mean there is a folder
-    # into which the object is being copied.
+    # Create a $folder$ object to simulate a folder created by the legacy GCS
+    # console (or various other tools), which gsutil understands to mean there
+    # is a folder into which the object is being copied.
     dst_bucket_uri = self.CreateBucket()
     self.CreateObject(bucket_uri=dst_bucket_uri, object_name='abc_$folder$',
                       contents='')
     src_dir = self.CreateTempDir(test_files=[('dir0', 'dir1', 'f1')])
     self.RunCommand('cp', ['-R', os.path.join('dir0', 'dir1'),
                            suri(dst_bucket_uri, 'abc')], cwd=src_dir)
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'abc_$folder$'),
                     suri(dst_bucket_uri, 'abc', 'dir1', 'f1')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingRelativePathSubDirToBucketSubdirSignifiedBySlash(self):
     """Tests recursively copying relative sub-directory to bucket subdir.
 
     Subdir is signified by a / object.
     """
     dst_bucket_uri = self.CreateBucket()
     src_dir = self.CreateTempDir(test_files=[('dir0', 'dir1', 'f1')])
     self.RunCommand('cp', ['-R', os.path.join('dir0', 'dir1'),
                            suri(dst_bucket_uri, 'abc') + '/'], cwd=src_dir)
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'abc', 'dir1', 'f1')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingRelativePathSubDirToBucket(self):
     """Tests recursively copying relative sub-directory to a bucket."""
     dst_bucket_uri = self.CreateBucket()
     src_dir = self.CreateTempDir(test_files=[('dir0', 'dir1', 'f1')])
     self.RunCommand('cp', ['-R', os.path.join('dir0', 'dir1'),
                            suri(dst_bucket_uri)], cwd=src_dir)
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'dir1', 'f1')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingDotSlashToBucket(self):
     """Tests copying ./ to a bucket produces expected naming."""
     # When running a command like gsutil cp -r . gs://dest we expect the dest
     # obj names to be of the form gs://dest/abc, not gs://dest/./abc.
     dst_bucket_uri = self.CreateBucket()
     src_dir = self.CreateTempDir(test_files=['foo'])
     for rel_src_dir in ['.', '.%s' % os.sep]:
       self.RunCommand('cp', ['-R', rel_src_dir, suri(dst_bucket_uri)],
                       cwd=src_dir)
       actual = set(str(u) for u in self._test_wildcard_iterator(
           suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
       expected = set([suri(dst_bucket_uri, 'foo')])
       self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingDirContainingOneFileToBucket(self):
     """Tests copying a directory containing 1 file to a bucket.
 
     We test this case to ensure that correct bucket handling isn't dependent
     on the copy being treated as a multi-source copy.
     """
     dst_bucket_uri = self.CreateBucket()
     src_dir = self.CreateTempDir(test_files=[('dir0', 'dir1', 'foo')])
     self.RunCommand('cp', ['-R', os.path.join(src_dir, 'dir0', 'dir1'),
                            suri(dst_bucket_uri)])
@@ skipping 53 matching lines @@
   def testCopyingFileToDir(self):
     """Tests copying one file to a directory."""
     src_file = self.CreateTempFile(file_name='foo')
     dst_dir = self.CreateTempDir()
     self.RunCommand('cp', [src_file, dst_dir])
     actual = list(self._test_wildcard_iterator(
         '%s%s*' % (dst_dir, os.sep)).IterAll(expand_top_level_buckets=True))
     self.assertEqual(1, len(actual))
     self.assertEqual(suri(dst_dir, 'foo'), str(actual[0]))
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingFileToObjectWithConsecutiveSlashes(self):
     """Tests copying a file to an object containing consecutive slashes."""
     src_file = self.CreateTempFile(file_name='f0')
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', [src_file, suri(dst_bucket_uri) + '//obj'])
     actual = list(self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     self.assertEqual(1, len(actual))
     self.assertEqual('/obj', actual[0].root_object.name)
 
@@ skipping 64 matching lines @@
                         cwd=dst_dir)
       actual = set()
       for dirname, dirnames, filenames in os.walk(dst_dir):
         for subdirname in dirnames:
           actual.add(os.path.join(dirname, subdirname))
         for filename in filenames:
           actual.add(os.path.join(dirname, filename))
       expected = set([os.path.join(dst_dir, 'f1')])
       self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingObjsAndFilesToBucket(self):
     """Tests copying objects and files to a bucket."""
     src_bucket_uri = self.CreateBucket(test_objects=['f1'])
     src_dir = self.CreateTempDir(test_files=['f2'])
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', ['-R', suri(src_bucket_uri, '**'),
                            '%s%s**' % (src_dir, os.sep), suri(dst_bucket_uri)])
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'f1'), suri(dst_bucket_uri, 'f2')])
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingSubdirRecursiveToNonexistentSubdir(self):
     """Tests copying a directory with a single file recursively to a bucket.
 
     The file should end up in a new bucket subdirectory with the file's
     directory structure starting below the recursive copy point, as in Unix cp.
 
     Example:
       filepath: dir1/dir2/foo
       cp -r dir1 dir3
       Results in dir3/dir2/foo being created.
@@ skipping 219 matching lines @@
 
   def testSetDefAclOnObjectFails(self):
     """Test that the 'defacl set' command fails when run against an object."""
     src_bucket_uri = self.CreateBucket()
     try:
       self.RunCommand('defacl', ['set', 'private', suri(src_bucket_uri, '*')])
       self.fail('Did not get expected CommandException')
     except CommandException, e:
       self.assertIn('URL must name a bucket', e.reason)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testMinusDOptionWorks(self):
     """Tests using gsutil -D option."""
     src_file = self.CreateTempFile(file_name='f0')
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', [src_file, suri(dst_bucket_uri)], debug=3)
     actual = list(self._test_wildcard_iterator(
         suri(dst_bucket_uri, '*')).IterAll(expand_top_level_buckets=True))
     self.assertEqual(1, len(actual))
     self.assertEqual('f0', actual[0].root_object.name)
 
-  def DownloadTestHelper(self, func):
-    """Test resumable download with custom test function.
-
-    The custom function distorts downloaded data. We expect an exception to be
-    raised and the dest file to be removed.
-
-    Args:
-      func: Custom test function used to distort the downloaded data.
-    """
-    object_uri = self.CreateObject(contents='foo')
-    # Need to explicitly tell the key to populate its etag so that hash
-    # validation will be performed.
-    object_uri.get_key().set_etag()
-    dst_dir = self.CreateTempDir()
-    got_expected_exception = False
-    try:
-      self.RunCommand('cp', [suri(object_uri), dst_dir], test_method=func)
-      self.fail('Did not get expected CommandException')
-    except HashMismatchException:
-      self.assertFalse(os.listdir(dst_dir))
-      got_expected_exception = True
-    except Exception, e:
-      self.fail('Unexpected exception raised: %s' % e)
-    if not got_expected_exception:
-      self.fail('Did not get expected CommandException')
-
-  def testDownloadWithObjectSizeChange(self):
-    """Test resumable download on an object that changes size.
-
-    Size change occurs before the downloaded file's checksum is validated.
-    """
-    self.DownloadTestHelper(_Append)
-
-  def testDownloadWithFileContentChange(self):
-    """Tests resumable download on an object that changes content.
-
-    Content change occurs before the downloaded file's checksum is validated.
-    """
-    self.DownloadTestHelper(_Overwrite)
-
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testFlatCopyingObjsAndFilesToBucketSubDir(self):
     """Tests copying flatly listed objects and files to bucket subdir."""
     src_bucket_uri = self.CreateBucket(test_objects=['f0', 'd0/f1', 'd1/d2/f2'])
     src_dir = self.CreateTempDir(test_files=['f3', ('d3', 'f4'),
                                              ('d4', 'd5', 'f5')])
     dst_bucket_uri = self.CreateBucket(test_objects=['dst_subdir0/existing',
                                                      'dst_subdir1/existing'])
     # Test with and without final slash on dest subdir.
     for i, final_char in enumerate(('/', '')):
       self.RunCommand(
           'cp', ['-R', suri(src_bucket_uri, '**'), os.path.join(src_dir, '**'),
                  suri(dst_bucket_uri, 'dst_subdir%d' % i) + final_char])
 
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set()
     for i in range(2):
       expected.add(suri(dst_bucket_uri, 'dst_subdir%d' % i, 'existing'))
       for j in range(6):
         expected.add(suri(dst_bucket_uri, 'dst_subdir%d' % i, 'f%d' % j))
     self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testRecursiveCopyObjsAndFilesToExistingBucketSubDir(self):
     """Tests recursive copy of objects and files to existing bucket subdir."""
     src_bucket_uri = self.CreateBucket(test_objects=['f0', 'nested/f1'])
     dst_bucket_uri = self.CreateBucket(test_objects=[
         'dst_subdir0/existing_obj', 'dst_subdir1/existing_obj'])
     src_dir = self.CreateTempDir(test_files=['f2', ('nested', 'f3')])
     # Test with and without final slash on dest subdir.
     for i, final_char in enumerate(('/', '')):
       self.RunCommand(
           'cp', ['-R', suri(src_bucket_uri), src_dir,
                  suri(dst_bucket_uri, 'dst_subdir%d' % i) + final_char])
       actual = set(str(u) for u in self._test_wildcard_iterator(
           suri(dst_bucket_uri, 'dst_subdir%d' % i, '**')).IterAll(
               expand_top_level_buckets=True))
       tmp_dirname = os.path.split(src_dir)[1]
       bucketname = src_bucket_uri.bucket_name
       expected = set([
           suri(dst_bucket_uri, 'dst_subdir%d' % i, 'existing_obj'),
           suri(dst_bucket_uri, 'dst_subdir%d' % i, bucketname, 'f0'),
           suri(dst_bucket_uri, 'dst_subdir%d' % i, bucketname, 'nested', 'f1'),
           suri(dst_bucket_uri, 'dst_subdir%d' % i, tmp_dirname, 'f2'),
           suri(dst_bucket_uri, 'dst_subdir%d' % i, tmp_dirname, 'nested', 'f3')
       ])
       self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testRecursiveCopyObjsAndFilesToNonExistentBucketSubDir(self):
     """Tests recursive copy of objs + files to non-existent bucket subdir."""
     src_bucket_uri = self.CreateBucket(test_objects=['f0', 'nested/f1'])
     src_dir = self.CreateTempDir(test_files=['f2', ('nested', 'f3')])
     dst_bucket_uri = self.CreateBucket()
     self.RunCommand('cp', ['-R', src_dir, suri(src_bucket_uri),
                            suri(dst_bucket_uri, 'dst_subdir')])
     actual = set(str(u) for u in self._test_wildcard_iterator(
         suri(dst_bucket_uri, '**')).IterAll(expand_top_level_buckets=True))
     expected = set([suri(dst_bucket_uri, 'dst_subdir', 'f0'),
@@ skipping 131 matching lines @@
       self.RunCommand('cp', [
           suri(src_bucket_uri, 'obj0'),
           suri(dst_bucket_uri, 'dir%d' % i) + final_dst_char])
       actual = set(str(u) for u in self._test_wildcard_iterator(
           suri(dst_bucket_uri, 'dir%d' % i, '**')).IterAll(
               expand_top_level_buckets=True))
       expected = set([suri(dst_bucket_uri, 'dir%d' % i, 'obj0'),
                       suri(dst_bucket_uri, 'dir%d' % i, 'existing')])
       self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingWildcardedFilesToBucketSubDir(self):
     """Tests copying wildcarded files to a bucket subdir."""
     dst_bucket_uri = self.CreateBucket(test_objects=['subdir0/existing',
                                                      'subdir1/existing'])
     src_dir = self.CreateTempDir(test_files=['f0', 'f1', 'f2'])
     # Test with and without final slash on dest subdir.
     for i, final_dst_char in enumerate(('', '/')):
       self.RunCommand(
           'cp', [os.path.join(src_dir, 'f?'),
                  suri(dst_bucket_uri, 'subdir%d' % i) + final_dst_char])
       actual = set(str(u) for u in self._test_wildcard_iterator(
           suri(dst_bucket_uri, 'subdir%d' % i, '**')).IterAll(
               expand_top_level_buckets=True))
       expected = set([suri(dst_bucket_uri, 'subdir%d' % i, 'existing'),
                       suri(dst_bucket_uri, 'subdir%d' % i, 'f0'),
                       suri(dst_bucket_uri, 'subdir%d' % i, 'f1'),
                       suri(dst_bucket_uri, 'subdir%d' % i, 'f2')])
       self.assertEqual(expected, actual)
 
-  # @PerformsFileToObjectUpload
+  # @SequentialAndParallelTransfer
   def testCopyingOneNestedFileToBucketSubDir(self):
     """Tests copying one nested file to a bucket subdir."""
     dst_bucket_uri = self.CreateBucket(test_objects=['d0/placeholder',
                                                      'd1/placeholder'])
     src_dir = self.CreateTempDir(test_files=[('d3', 'd4', 'nested', 'f1')])
     # Test with and without final slash on dest subdir.
     for i, final_dst_char in enumerate(('', '/')):
       self.RunCommand('cp', ['-r', suri(src_dir, 'd3'),
                              suri(dst_bucket_uri, 'd%d' % i) + final_dst_char])
       actual = set(str(u) for u in self._test_wildcard_iterator(
@@ skipping 198 matching lines @@
 
   def testMakeBucketsCommand(self):
     """Test mb on existing bucket."""
     dst_bucket_uri = self.CreateBucket()
     try:
       self.RunCommand('mb', [suri(dst_bucket_uri)])
       self.fail('Did not get expected StorageCreateError')
     except ServiceException, e:
       self.assertEqual(e.status, 409)
 
-  def testRemoveBucketsCommand(self):
-    """Test rb on non-existent bucket."""
-    dst_bucket_uri = self.CreateBucket()
-    try:
-      self.RunCommand(
-          'rb', ['gs://no_exist_%s' % dst_bucket_uri.bucket_name])
-      self.fail('Did not get expected NotFoundException')
-    except NotFoundException, e:
-      self.assertEqual(e.status, 404)
-
   def testRemoveObjsCommand(self):
     """Test rm command on non-existent object."""
     dst_bucket_uri = self.CreateBucket()
     try:
       self.RunCommand('rm', [suri(dst_bucket_uri, 'non_existent')])
       self.fail('Did not get expected CommandException')
     except CommandException, e:
       self.assertIn('No URLs matched', e.reason)
 
   # Now that gsutil ver computes a checksum it adds 1-3 seconds to test run
   # time (for in memory mocked tests that otherwise take ~ 0.1 seconds). Since
   # it provides very little test value, we're leaving this test commented out.
   # def testVerCommmandRuns(self):
   #   """Test that the Ver command basically runs"""
   #   self.RunCommand('ver', [])