gcloud 0.0.4 → 0.0.6

data/packages/gsutil/gslib/tests/test_cp.py

@@ -0,0 +1,267 @@
+# Copyright 2013 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.
+
+import boto
+import os
+import re
+import gslib.tests.testcase as testcase
+from gslib.util import TWO_MB
+from boto import storage_uri
+from gslib.tests.util import ObjectToURI as suri
+
+
+CURDIR = os.path.abspath(os.path.dirname(__file__))
+TEST_DATA_DIR = os.path.join(CURDIR, 'test_data')
+
+
+class TestCp(testcase.GsUtilIntegrationTestCase):
+  """Integration tests for cp command."""
+
+  def _get_test_file(self, name):
+    return os.path.join(TEST_DATA_DIR, name)
+
+  def test_noclobber(self):
+    key_uri = self.CreateObject(contents='foo')
+    fpath = self.CreateTempFile(contents='bar')
+    stderr = self.RunGsUtil(['cp', '-n', fpath, suri(key_uri)],
+                            return_stderr=True)
+    self.assertIn('Skipping existing item: %s' % suri(key_uri), stderr)
+    self.assertEqual(key_uri.get_contents_as_string(), 'foo')
+    stderr = self.RunGsUtil(['cp', '-n', suri(key_uri), fpath], 
+                            return_stderr=True)
+    with open(fpath, 'r') as f:
+      self.assertIn('Skipping existing item: %s' % suri(f), stderr)
+      self.assertEqual(f.read(), 'bar')
+
+  def test_copy_in_cloud_noclobber(self):
+    bucket1_uri = self.CreateBucket()
+    bucket2_uri = self.CreateBucket()
+    key_uri = self.CreateObject(bucket_uri=bucket1_uri, contents='foo')
+    stderr = self.RunGsUtil(['cp', suri(key_uri), suri(bucket2_uri)], 
+                            return_stderr=True)
+    self.assertEqual(stderr.count('Copying'), 1)
+    stderr = self.RunGsUtil(['cp', '-n', suri(key_uri), suri(bucket2_uri)],
+                            return_stderr=True)
+    self.assertIn('Skipping existing item: %s' % suri(bucket2_uri, 
+                  key_uri.object_name), stderr)
+
+  def test_streaming(self):
+    bucket_uri = self.CreateBucket()
+    stderr = self.RunGsUtil(['cp', '-', '%s' % suri(bucket_uri, 'foo')],
+                            stdin='bar', return_stderr=True)
+    self.assertIn('Copying from <STDIN>', stderr)
+    key_uri = bucket_uri.clone_replace_name('foo')
+    self.assertEqual(key_uri.get_contents_as_string(), 'bar')
+
+  # TODO: Implement a way to test both with and without using magic file.
+
+  def test_detect_content_type(self):
+    bucket_uri = self.CreateBucket()
+    dsturi = suri(bucket_uri, 'foo')
+
+    self.RunGsUtil(['cp', self._get_test_file('test.mp3'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\taudio/mpeg', stdout)
+
+    self.RunGsUtil(['cp', self._get_test_file('test.gif'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\timage/gif', stdout)
+
+  def test_content_type_override_default(self):
+    bucket_uri = self.CreateBucket()
+    dsturi = suri(bucket_uri, 'foo')
+
+    self.RunGsUtil(['-h', 'Content-Type:', 'cp',
+                    self._get_test_file('test.mp3'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\tbinary/octet-stream', stdout)
+
+    self.RunGsUtil(['-h', 'Content-Type:', 'cp',
+                    self._get_test_file('test.gif'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\tbinary/octet-stream', stdout)
+
+  def test_content_type_override(self):
+    bucket_uri = self.CreateBucket()
+    dsturi = suri(bucket_uri, 'foo')
+
+    self.RunGsUtil(['-h', 'Content-Type:', 'cp',
+                    self._get_test_file('test.mp3'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\tbinary/octet-stream', stdout)
+
+    self.RunGsUtil(['-h', 'Content-Type:', 'cp',
+                    self._get_test_file('test.gif'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\tbinary/octet-stream', stdout)
+
+  def test_foo_noct(self):
+    bucket_uri = self.CreateBucket()
+    dsturi = suri(bucket_uri, 'foo')
+    fpath = self.CreateTempFile(contents='foo/bar\n')
+    self.RunGsUtil(['cp', fpath, dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    USE_MAGICFILE = boto.config.getbool('GSUtil', 'use_magicfile', False)
+    content_type = 'text/plain' if USE_MAGICFILE else 'application/octet-stream'
+    self.assertIn('Content-Type:\t%s' % content_type, stdout)
+
+  def test_content_type_mismatches(self):
+    bucket_uri = self.CreateBucket()
+    dsturi = suri(bucket_uri, 'foo')
+    fpath = self.CreateTempFile(contents='foo/bar\n')
+
+    self.RunGsUtil(['-h', 'Content-Type:image/gif', 'cp',
+                    self._get_test_file('test.mp3'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\timage/gif', stdout)
+
+    self.RunGsUtil(['-h', 'Content-Type:image/gif', 'cp',
+                    self._get_test_file('test.gif'), dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\timage/gif', stdout)
+
+    self.RunGsUtil(['-h', 'Content-Type:image/gif', 'cp', fpath, dsturi])
+    stdout = self.RunGsUtil(['ls', '-L', dsturi], return_stdout=True)
+    self.assertIn('Content-Type:\timage/gif', stdout)
+
+  def test_versioning(self):
+    bucket_uri = self.CreateVersionedBucket()
+    k1_uri = self.CreateObject(bucket_uri=bucket_uri, contents='data2')
+    k2_uri = self.CreateObject(bucket_uri=bucket_uri, contents='data1')
+    g1 = k2_uri.generation
+    self.RunGsUtil(['cp', suri(k1_uri), suri(k2_uri)])
+    k2_uri = bucket_uri.clone_replace_name(k2_uri.object_name)
+    k2_uri = bucket_uri.clone_replace_key(k2_uri.get_key())
+    g2 = k2_uri.generation
+    k2_uri.set_contents_from_string('data3')
+    g3 = k2_uri.generation
+
+    fpath = self.CreateTempFile()
+    # Check to make sure current version is data3.
+    self.RunGsUtil(['cp', k2_uri.versionless_uri, fpath])
+    with open(fpath, 'r') as f:
+      self.assertEqual(f.read(), 'data3')
+
+    # Check contents of all three versions
+    self.RunGsUtil(['cp', '%s#%s' % (k2_uri.versionless_uri, g1), fpath])
+    with open(fpath, 'r') as f:
+      self.assertEqual(f.read(), 'data1')
+    self.RunGsUtil(['cp', '%s#%s' % (k2_uri.versionless_uri, g2), fpath])
+    with open(fpath, 'r') as f:
+      self.assertEqual(f.read(), 'data2')
+    self.RunGsUtil(['cp', '%s#%s' % (k2_uri.versionless_uri, g3), fpath])
+    with open(fpath, 'r') as f:
+      self.assertEqual(f.read(), 'data3')
+
+    # Copy first version to current and verify.
+    self.RunGsUtil(['cp', '%s#%s' % (k2_uri.versionless_uri, g1),
+                    k2_uri.versionless_uri])
+    self.RunGsUtil(['cp', k2_uri.versionless_uri, fpath])
+    with open(fpath, 'r') as f:
+      self.assertEqual(f.read(), 'data1')
+
+    # Attempt to specify a version-specific URI for destination.
+    stderr = self.RunGsUtil(['cp', fpath, k2_uri.uri], return_stderr=True,
+                            expected_status=1)
+    self.assertIn('cannot be the destination for gsutil cp', stderr)
+
+  def test_cp_v_option(self):
+    # Tests that cp -v option returns the created object's version-specific URI.
+    bucket_uri = self.CreateVersionedBucket()
+    k1_uri = self.CreateObject(bucket_uri=bucket_uri, contents='data1')
+    k2_uri = self.CreateObject(bucket_uri=bucket_uri, contents='data2')
+    g1 = k1_uri.generation
+
+    # Case 1: Upload file to object using one-shot PUT.
+    tmpdir = self.CreateTempDir()
+    fpath1 = self.CreateTempFile(tmpdir=tmpdir, contents='data1')
+    self._run_cp_minus_v_test('-v', fpath1, k2_uri.uri)
+
+    # Case 2: Upload file to object using resumable upload.
+    size_threshold = boto.config.get('GSUtil', 'resumable_threshold', TWO_MB)
+    file_as_string = os.urandom(size_threshold)
+    tmpdir = self.CreateTempDir()
+    fpath1 = self.CreateTempFile(tmpdir=tmpdir, contents=file_as_string)
+    self._run_cp_minus_v_test('-v', fpath1, k2_uri.uri)
+
+    # Case 3: Upload stream to object.
+    self._run_cp_minus_v_test('-v', '-', k2_uri.uri)
+
+    # Case 4: Download object to file. For this case we just expect output of
+    # gsutil cp -v to be the URI of the file.
+    tmpdir = self.CreateTempDir()
+    fpath1 = self.CreateTempFile(tmpdir=tmpdir)
+    dst_uri = storage_uri(fpath1)
+    stderr = self.RunGsUtil(['cp', '-v', suri(k1_uri), suri(dst_uri)],
+                            return_stderr=True)
+    self.assertIn('Created: %s' % dst_uri.uri, stderr.split('\n')[-2])
+
+    # Case 5: Daisy-chain from object to object.
+    self._run_cp_minus_v_test('-Dv', k1_uri.uri, k2_uri.uri)
+
+    # Case 6: Copy object to object in-the-cloud.
+    # TODO: Uncomment this test once copy-in-the-cloud returns version-specific
+    # URI.
+    #self._run_cp_minus_v_test('-v', k1_uri.uri, k2_uri.uri)
+
+  def _run_cp_minus_v_test(self, opt, src_str, dst_str):
+    stderr = self.RunGsUtil(['cp', opt, src_str, dst_str], return_stderr=True)
+    match = re.search(r'Created: (.*)\n', stderr)
+    self.assertIsNotNone(match)
+    created_uri = match.group(1)
+    stdout = self.RunGsUtil(['ls', '-a', dst_str], return_stdout=True)
+    lines = stdout.split('\n')
+    # Final (most recent) object should match the "Created:" URI. This is
+    # in second-to-last line (last line is '\n').
+    self.assertEqual(created_uri, lines[-2])
+
+  def test_stdin_args(self):
+    tmpdir = self.CreateTempDir()
+    fpath1 = self.CreateTempFile(tmpdir=tmpdir, contents='data1')
+    fpath2 = self.CreateTempFile(tmpdir=tmpdir, contents='data2')
+    bucket_uri = self.CreateBucket()
+    self.RunGsUtil(['cp', '-I', suri(bucket_uri)],
+                   stdin='\n'.join((fpath1, fpath2)))
+    stdout = self.RunGsUtil(['ls', suri(bucket_uri)], return_stdout=True)
+    self.assertIn(os.path.basename(fpath1), stdout)
+    self.assertIn(os.path.basename(fpath2), stdout)
+    self.assertNumLines(stdout, 2)
+
+  def test_daisy_chain_cp(self):
+    # Daisy chain mode is required for copying across storage classes,
+    # so create 2 buckets and attempt to copy without vs with daisy chain mode.
+    bucket1_uri = self.CreateBucket(storage_class='STANDARD')
+    bucket2_uri = self.CreateBucket(
+        storage_class='DURABLE_REDUCED_AVAILABILITY')
+    key_uri = self.CreateObject(bucket_uri=bucket1_uri, contents='foo')
+    stderr = self.RunGsUtil(['cp', suri(key_uri), suri(bucket2_uri)], 
+                            return_stderr=True, expected_status=1)
+    self.assertIn('Copy-in-the-cloud disallowed', stderr)
+    key_uri = self.CreateObject(bucket_uri=bucket1_uri, contents='foo')
+    stderr = self.RunGsUtil(['cp', '-D', suri(key_uri), suri(bucket2_uri)], 
+                            return_stderr=True)
+    self.assertNotIn('Copy-in-the-cloud disallowed', stderr)
+
+  def test_cp_key_to_local_stream(self):
+    bucket_uri = self.CreateBucket()
+    contents = 'foo'
+    key_uri = self.CreateObject(bucket_uri=bucket_uri, contents=contents)
+    stdout = self.RunGsUtil(['cp', suri(key_uri), '-'], return_stdout=True)
+    self.assertIn(contents, stdout)
+
+  def test_cp_local_file_to_local_stream(self):
+    contents = 'content'
+    fpath = self.CreateTempFile(contents=contents)
+    stdout = self.RunGsUtil(['cp', fpath, '-'], return_stdout=True)
+    self.assertIn(contents, stdout)

data/packages/gsutil/gslib/tests/test_ls.py

@@ -0,0 +1,66 @@
+# Copyright 2013 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.
+
+import gslib.tests.testcase as testcase
+from gslib.tests.util import ObjectToURI as suri
+
+
+class TestLs(testcase.GsUtilIntegrationTestCase):
+  """Integration tests for ls command."""
+
+  def test_blank_ls(self):
+    self.RunGsUtil(['ls'])
+
+  def test_empty_bucket(self):
+    bucket_uri = self.CreateBucket()
+    stdout = self.RunGsUtil(['ls', suri(bucket_uri)], return_stdout=True)
+    self.assertEqual('', stdout)
+
+  def test_empty_bucket_with_b(self):
+    bucket_uri = self.CreateBucket()
+    stdout = self.RunGsUtil(['ls', '-b', suri(bucket_uri)], return_stdout=True)
+    self.assertEqual('%s/\n' % suri(bucket_uri), stdout)
+
+  def test_with_one_object(self):
+    bucket_uri = self.CreateBucket(test_objects=1)
+    stdout = self.RunGsUtil(['ls', suri(bucket_uri)], return_stdout=True)
+    objuri = [suri(bucket_uri.clone_replace_name(key.name))
+              for key in bucket_uri.list_bucket()][0]
+    self.assertEqual('%s\n' % objuri, stdout)
+
+  def test_subdir(self):
+    bucket_uri = self.CreateBucket(test_objects=1)
+    k1_uri = bucket_uri.clone_replace_name('foo')
+    k1_uri.set_contents_from_string('baz')
+    k2_uri = bucket_uri.clone_replace_name('dir/foo')
+    k2_uri.set_contents_from_string('bar')
+    stdout = self.RunGsUtil(['ls', '%s/dir' % suri(bucket_uri)],
+                            return_stdout=True)
+    self.assertEqual('%s\n' % suri(k2_uri), stdout)
+    stdout = self.RunGsUtil(['ls', suri(k1_uri)], return_stdout=True)
+    self.assertEqual('%s\n' % suri(k1_uri), stdout)
+
+  def test_versioning(self):
+    bucket1_uri = self.CreateBucket(test_objects=1)
+    bucket2_uri = self.CreateVersionedBucket(test_objects=1)
+    bucket_list = list(bucket1_uri.list_bucket())
+    objuri = [bucket1_uri.clone_replace_key(key).versionless_uri
+              for key in bucket_list][0]
+    self.RunGsUtil(['cp', objuri, suri(bucket2_uri)])
+    self.RunGsUtil(['cp', objuri, suri(bucket2_uri)])
+    stdout = self.RunGsUtil(['ls', '-a', suri(bucket2_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 3)
+    stdout = self.RunGsUtil(['ls', '-la', suri(bucket2_uri)], return_stdout=True)
+    self.assertIn('%s#' % bucket2_uri.clone_replace_name(bucket_list[0].name), stdout)
+    self.assertIn('meta_generation=', stdout)

data/packages/gsutil/gslib/tests/test_mv.py

@@ -0,0 +1,69 @@
+# Copyright 2013 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.
+
+import gslib.tests.testcase as testcase
+from gslib.tests.util import ObjectToURI as suri
+
+
+class TestMv(testcase.GsUtilIntegrationTestCase):
+  """Integration tests for mv command."""
+
+  def test_moving(self):
+    # Create two buckets, one with 2 objects and one with 0 objects, and verify.
+    bucket1_uri = self.CreateBucket(test_objects=2)
+    stdout = self.RunGsUtil(['ls', suri(bucket1_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 2)
+    bucket2_uri = self.CreateBucket()
+    stdout = self.RunGsUtil(['ls', suri(bucket2_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 0)
+
+    # Move two objects from bucket1 to bucket2.
+    objs = [bucket1_uri.clone_replace_key(key).versionless_uri
+            for key in bucket1_uri.list_bucket()]
+    cmd = (['-m', 'mv'] + objs + [suri(bucket2_uri)])
+    stderr = self.RunGsUtil(cmd, return_stderr=True)
+    self.assertEqual(stderr.count('Copying'), 2)
+    self.assertEqual(stderr.count('Removing'), 2)
+
+    # Verify objects were moved.
+    stdout = self.RunGsUtil(['ls', suri(bucket1_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 0)
+    stdout = self.RunGsUtil(['ls', suri(bucket2_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 2)
+
+    # Remove one of the objects.
+    objs = [bucket2_uri.clone_replace_key(key).versionless_uri
+            for key in bucket2_uri.list_bucket()]
+    obj1 = objs[0]
+    self.RunGsUtil(['rm', obj1])
+
+    # Verify there are now 1 and 0 objects.
+    stdout = self.RunGsUtil(['ls', suri(bucket1_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 0)
+    stdout = self.RunGsUtil(['ls', suri(bucket2_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 1)
+
+    # Move the 1 remaining object back.
+    objs = [suri(bucket2_uri.clone_replace_key(key))
+            for key in bucket2_uri.list_bucket()]
+    cmd = (['-m', 'mv'] + objs + [suri(bucket1_uri)])
+    stderr = self.RunGsUtil(cmd, return_stderr=True)
+    self.assertEqual(stderr.count('Copying'), 1)
+    self.assertEqual(stderr.count('Removing'), 1)
+
+    # Verify object moved.
+    stdout = self.RunGsUtil(['ls', suri(bucket1_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 1)
+    stdout = self.RunGsUtil(['ls', suri(bucket2_uri)], return_stdout=True)
+    self.assertNumLines(stdout, 0)

data/packages/gsutil/gslib/tests/test_naming.py

@@ -0,0 +1,989 @@
+# 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:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""Tests for gsutil naming logic.
+The test code in this file runs against an in-memory storage service mock,
+so runs very quickly. This is valuable for testing changes that impact the
+naming rules, since those rules are complex and it's useful to be able to
+make small incremental changes and rerun the tests frequently. Additional
+end-to-end tests (which send traffic to the production Google Cloud Storage
+service) are available via the gsutil test command.
+"""
+
+import gzip
+import os
+import posixpath
+import StringIO
+
+import boto
+from boto.exception import StorageResponseError
+from boto import storage_uri
+
+from gslib.commands import cp
+from gslib.exception import CommandException
+import gslib.tests.testcase as testcase
+from gslib.tests.util import ObjectToURI as suri
+
+
+class GsutilNamingTests(testcase.GsUtilUnitTestCase):
+  """gsutil command method test suite"""
+
+  def testGetPathBeforeFinalDir(self):
+    """Tests _GetPathBeforeFinalDir() (unit test)"""
+    self.assertEqual('gs://',
+                     cp._GetPathBeforeFinalDir(storage_uri('gs://bucket/')))
+    self.assertEqual('gs://bucket',
+                     cp._GetPathBeforeFinalDir(storage_uri('gs://bucket/dir/')))
+    self.assertEqual('gs://bucket',
+                     cp._GetPathBeforeFinalDir(storage_uri('gs://bucket/dir')))
+    self.assertEqual('gs://bucket/dir',
+                     cp._GetPathBeforeFinalDir(
+                         storage_uri('gs://bucket/dir/obj')))
+    src_dir = self.CreateTempDir()
+    subdir = os.path.join(src_dir, 'subdir')
+    os.mkdir(subdir)
+    self.assertEqual(suri(src_dir),
+                     cp._GetPathBeforeFinalDir(storage_uri(suri(subdir))))
+
+  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, '**')).IterUris())
+    self.assertEqual(1, len(actual))
+    self.assertEqual('f0', actual[0].object_name)
+
+  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, '**')).IterUris())
+    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)
+
+  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, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'dir0', 'f1')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingRelPathSubDirToBucketSubdirWithDollarFolderObj(self):
+    """Tests recursively copying relative sub-directory to bucket subdir
+    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.
+    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, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'abc_$folder$'),
+                    suri(dst_bucket_uri, 'abc', 'dir1', 'f1')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingRelativePathSubDirToBucketSubdirSignifiedBySlash(self):
+    """Tests recursively copying relative sub-directory to bucket subdir
+    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, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'abc', 'dir1', 'f1')])
+    self.assertEqual(expected, actual)
+
+  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, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'dir1', 'f1')])
+    self.assertEqual(expected, actual)
+
+  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, '**')).IterUris())
+      expected = set([suri(dst_bucket_uri, 'foo')])
+      self.assertEqual(expected, actual)
+
+  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)])
+    actual = list((str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris()))
+    self.assertEqual(1, len(actual))
+    self.assertEqual(suri(dst_bucket_uri, 'dir1', 'foo'), actual[0])
+
+  def testCopyingBucketToDir(self):
+    """Tests copying from a bucket to a directory"""
+    src_bucket_uri = self.CreateBucket(test_objects=['foo', 'dir/foo2'])
+    dst_dir = self.CreateTempDir()
+    self.RunCommand('cp', ['-R', suri(src_bucket_uri), dst_dir])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        '%s%s**' % (dst_dir, os.sep)).IterUris())
+    expected = set([suri(dst_dir, src_bucket_uri.bucket_name, 'foo'),
+                    suri(dst_dir, src_bucket_uri.bucket_name, 'dir', 'foo2')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingBucketToBucket(self):
+    """Tests copying from a bucket-only URI to a bucket"""
+    src_bucket_uri = self.CreateBucket(test_objects=['foo', 'dir/foo2'])
+    dst_bucket_uri = self.CreateBucket()
+    self.RunCommand('cp', ['-R', suri(src_bucket_uri), suri(dst_bucket_uri)])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([
+        suri(dst_bucket_uri, src_bucket_uri.bucket_name, 'foo'),
+        suri(dst_bucket_uri, src_bucket_uri.bucket_name, 'dir', 'foo2')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingDirectoryToDirectory(self):
+    """Tests copying from a directory to a directory"""
+    src_dir = self.CreateTempDir(test_files=['foo', ('dir', 'foo2')])
+    dst_dir = self.CreateTempDir()
+    self.RunCommand('cp', ['-R', src_dir, dst_dir])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        '%s%s**' % (dst_dir, os.sep)).IterUris())
+    src_dir_base = os.path.split(src_dir)[1]
+    expected = set([suri(dst_dir, src_dir_base, 'foo'),
+                    suri(dst_dir, src_dir_base, 'dir', 'foo2')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingFilesAndDirNonRecursive(self):
+    """Tests copying containing files and a directory without -R"""
+    src_dir = self.CreateTempDir(test_files=['foo', 'bar', ('d1', 'f2'),
+                                             ('d2', 'f3'), ('d3', 'd4', 'f4')])
+    dst_dir = self.CreateTempDir()
+    self.RunCommand('cp', ['%s%s*' % (src_dir, os.sep), dst_dir])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        '%s%s**' % (dst_dir, os.sep)).IterUris())
+    expected = set([suri(dst_dir, 'foo'), suri(dst_dir, 'bar')])
+    self.assertEqual(expected, actual)
+
+  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)).IterUris())
+    self.assertEqual(1, len(actual))
+    self.assertEqual(suri(dst_dir, 'foo'), actual[0].uri)
+
+  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, '**')).IterUris())
+    self.assertEqual(1, len(actual))
+    self.assertEqual('/obj', actual[0].object_name)
+
+  def testCopyingCompressedFileToBucket(self):
+    """Tests copying one file with compression to a bucket"""
+    src_file = self.CreateTempFile(contents='plaintext', file_name='f2.txt')
+    dst_bucket_uri = self.CreateBucket()
+    self.RunCommand('cp', ['-z', 'txt', src_file, suri(dst_bucket_uri)],)
+    actual = list(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '*')).IterUris())
+    self.assertEqual(1, len(actual))
+    expected_dst_uri = dst_bucket_uri.clone_replace_name('f2.txt')
+    self.assertEqual(expected_dst_uri.uri, actual[0])
+    dst_key = expected_dst_uri.get_key()
+    dst_key.open_read()
+    self.assertEqual('gzip', dst_key.content_encoding)
+    contents = dst_key.read()
+    f = gzip.GzipFile(fileobj=StringIO.StringIO(contents), mode='rb')
+    try:
+      self.assertEqual(f.read(), 'plaintext')
+    finally:
+      f.close()
+
+  def testCopyingObjectToObject(self):
+    """Tests copying an object to an object"""
+    src_bucket_uri = self.CreateBucket(test_objects=['obj'])
+    dst_bucket_uri = self.CreateBucket()
+    self.RunCommand('cp', [suri(src_bucket_uri, 'obj'), suri(dst_bucket_uri)])
+    actual = list(self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '*')).IterUris())
+    self.assertEqual(1, len(actual))
+    self.assertEqual('obj', actual[0].object_name)
+
+  def testCopyingObjsAndFilesToDir(self):
+    """Tests copying objects and files to a directory"""
+    src_bucket_uri = self.CreateBucket(test_objects=['f1'])
+    src_dir = self.CreateTempDir(test_files=['f2'])
+    dst_dir = self.CreateTempDir()
+    self.RunCommand('cp', ['-R', suri(src_bucket_uri, '**'),
+                           os.path.join(src_dir, '**'), dst_dir])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        os.path.join(dst_dir, '**')).IterUris())
+    expected = set([suri(dst_dir, 'f1'), suri(dst_dir, 'f2')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingObjToDot(self):
+    """Tests that copying an object to . or ./ downloads to correct name"""
+    src_bucket_uri = self.CreateBucket(test_objects=['f1'])
+    dst_dir = self.CreateTempDir()
+    for final_char in ('/', ''):
+      self.RunCommand('cp', [suri(src_bucket_uri, 'f1'), '.%s' % final_char],
+                      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)
+
+  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, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'f1'), suri(dst_bucket_uri, 'f2')])
+    self.assertEqual(expected, actual)
+
+  def testAttemptDirCopyWithoutRecursion(self):
+    """Tests copying a directory without -R"""
+    src_dir = self.CreateTempDir(test_files=1)
+    dst_dir = self.CreateTempDir()
+    try:
+      self.RunCommand('cp', [src_dir, dst_dir])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('No URIs matched', e.reason)
+
+  def testAttemptCopyingProviderOnlySrc(self):
+    """Attempts to copy a src specified as a provider-only URI"""
+    src_bucket_uri = self.CreateBucket()
+    try:
+      self.RunCommand('cp', ['gs://', suri(src_bucket_uri)])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('provider-only', e.reason)
+
+  def testAttemptCopyingOverlappingSrcDstFile(self):
+    """Attempts to an object atop itself"""
+    src_file = self.CreateTempFile()
+    try:
+      self.RunCommand('cp', [src_file, src_file])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('are the same file - abort', e.reason)
+
+  def testAttemptCopyingToMultiMatchWildcard(self):
+    """Attempts to copy where dst wildcard matches >1 obj"""
+    src_bucket_uri = self.CreateBucket()
+    try:
+      self.RunCommand('cp', [suri(src_bucket_uri, 'obj0'),
+                             suri(src_bucket_uri, '*')])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertNotEqual(e.reason.find('must match exactly 1 URI'), -1)
+
+  def testAttemptCopyingMultiObjsToFile(self):
+    """Attempts to copy multiple objects to a file"""
+    src_bucket_uri = self.CreateBucket(test_objects=2)
+    dst_file = self.CreateTempFile()
+    try:
+      self.RunCommand('cp', ['-R', suri(src_bucket_uri, '*'), dst_file])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('must name a directory, bucket, or', e.reason)
+
+  def testAttemptCopyingWithFileDirConflict(self):
+    """Attempts to copy objects that cause a file/directory conflict"""
+    # Create objects with name conflicts (a/b and a). Use 'dst' bucket because
+    # it gets cleared after each test.
+    bucket_uri = self.CreateBucket()
+    self.CreateObject(bucket_uri=bucket_uri, object_name='a')
+    self.CreateObject(bucket_uri=bucket_uri, object_name='b/a')
+    dst_dir = self.CreateTempDir()
+    try:
+      self.RunCommand('cp', ['-R', suri(bucket_uri), dst_dir])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertNotEqual('exists where a directory needs to be created',
+                          e.reason)
+
+  def testAttemptCopyingWithDirFileConflict(self):
+    """Attempts to copy an object that causes a directory/file conflict"""
+    # Create an object that conflicts with dest subdir.
+    tmpdir = self.CreateTempDir()
+    os.mkdir(os.path.join(tmpdir, 'abc'))
+    src_uri = self.CreateObject(object_name='abc', contents='bar')
+    try:
+      self.RunCommand('cp', [suri(src_uri), tmpdir + '/'])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertNotEqual('where the file needs to be created', e.reason)
+
+  def testWildcardMoveWithinBucket(self):
+    """Attempts to move using src wildcard that overlaps dest object.
+    We want to ensure that this doesn't stomp the result data. See the
+    comment starting with 'Expand wildcards before' in commands/mv.py
+    for details.
+    """
+    dst_bucket_uri = self.CreateBucket(test_objects=['old'])
+    self.RunCommand('mv', [suri(dst_bucket_uri, 'old*'),
+                           suri(dst_bucket_uri, 'new')])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'new')])
+    self.assertEqual(expected, actual)
+
+  def testLsNonExistentObjectWithPrefixName(self):
+    """Test ls of non-existent obj that matches prefix of existing objs"""
+    # Use an object name that matches a prefix of other names at that level, to
+    # ensure the ls subdir handling logic doesn't pick up anything extra.
+    src_bucket_uri = self.CreateBucket()
+    try:
+      output = self.RunCommand('ls', [suri(src_bucket_uri, 'obj')],
+                               return_stdout=True)
+    except CommandException, e:
+      self.assertIn('No such object', e.reason)
+
+  def testLsBucketNonRecursive(self):
+    """Test that ls of a bucket returns expected results"""
+    src_bucket_uri = self.CreateBucket(test_objects=['foo1', 'd0/foo2',
+                                                     'd1/d2/foo3'])
+    output = self.RunCommand('ls', [suri(src_bucket_uri, '*')],
+                             return_stdout=True)
+    expected = set([suri(src_bucket_uri, 'foo1'),
+                    suri(src_bucket_uri, 'd1', ':'),
+                    suri(src_bucket_uri, 'd1', 'd2') + src_bucket_uri.delim,
+                    suri(src_bucket_uri, 'd0', ':'),
+                    suri(src_bucket_uri, 'd0', 'foo2')])
+    expected.add('') # Blank line between subdir listings.
+    actual = set(output.split('\n'))
+    self.assertEqual(expected, actual)
+
+  def testLsBucketRecursive(self):
+    """Test that ls -R of a bucket returns expected results"""
+    src_bucket_uri = self.CreateBucket(test_objects=['foo1', 'd0/foo2',
+                                                     'd1/d2/foo3'])
+    output = self.RunCommand('ls', ['-R', suri(src_bucket_uri, '*')],
+                             return_stdout=True)
+    expected = set([suri(src_bucket_uri, 'foo1'),
+                    suri(src_bucket_uri, 'd1', ':'),
+                    suri(src_bucket_uri, 'd1', 'd2', ':'),
+                    suri(src_bucket_uri, 'd1', 'd2', 'foo3'),
+                    suri(src_bucket_uri, 'd0', ':'),
+                    suri(src_bucket_uri, 'd0', 'foo2')])
+    expected.add('') # Blank line between subdir listings.
+    actual = set(output.split('\n'))
+    self.assertEqual(expected, actual)
+
+  def testLsBucketRecursiveWithLeadingSlashObjectName(self):
+    """Test that ls -R of a bucket with an object that has leading slash"""
+    dst_bucket_uri = self.CreateBucket(test_objects=['f0'])
+    output = self.RunCommand('ls', ['-R', suri(dst_bucket_uri) + '*'],
+                             return_stdout=True)
+    expected = set([suri(dst_bucket_uri, 'f0')])
+    expected.add('') # Blank line between subdir listings.
+    actual = set(output.split('\n'))
+    self.assertEqual(expected, actual)
+
+  def testLsBucketSubdirNonRecursive(self):
+    """Test that ls of a bucket subdir returns expected results"""
+    src_bucket_uri = self.CreateBucket(test_objects=['src_subdir/foo',
+                                                     'src_subdir/nested/foo2'])
+    output = self.RunCommand('ls', [suri(src_bucket_uri, 'src_subdir')],
+                             return_stdout=True)
+    expected = set([
+        suri(src_bucket_uri, 'src_subdir', 'foo'),
+        suri(src_bucket_uri, 'src_subdir', 'nested') + src_bucket_uri.delim])
+    expected.add('') # Blank line between subdir listings.
+    actual = set(output.split('\n'))
+    self.assertEqual(expected, actual)
+
+  def testLsBucketSubdirRecursive(self):
+    """Test that ls -R of a bucket subdir returns expected results"""
+    src_bucket_uri = self.CreateBucket(test_objects=['src_subdir/foo',
+                                                     'src_subdir/nested/foo2'])
+    for final_char in ('/', ''):
+      output = self.RunCommand(
+          'ls', ['-R', suri(src_bucket_uri, 'src_subdir') + final_char],
+          return_stdout=True)
+      expected = set([
+        suri(src_bucket_uri, 'src_subdir', ':'),
+        suri(src_bucket_uri, 'src_subdir', 'foo'),
+        suri(src_bucket_uri, 'src_subdir', 'nested', ':'),
+        suri(src_bucket_uri, 'src_subdir', 'nested', 'foo2')])
+      expected.add('') # Blank line between subdir listings.
+      actual = set(output.split('\n'))
+      self.assertEqual(expected, actual)
+
+  def testSetAclOnBucketRuns(self):
+    """Test that the setacl command basically runs"""
+    # We don't test reading back the acl (via getacl command) because at present
+    # MockStorageService doesn't translate canned ACLs into actual ACL XML.
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('setacl', ['private', suri(src_bucket_uri)])
+
+  def testSetAclOnWildcardNamedBucketRuns(self):
+    """Test that setacl basically runs against wildcard-named bucket"""
+    # We don't test reading back the acl (via getacl command) because at present
+    # MockStorageService doesn't translate canned ACLs into actual ACL XML.
+    src_bucket_uri = self.CreateBucket(test_objects=['f0'])
+    self.RunCommand('setacl', ['private', suri(src_bucket_uri)[:-2] + '*'])
+
+  def testSetAclOnObjectRuns(self):
+    """Test that the setacl command basically runs"""
+    src_bucket_uri = self.CreateBucket(test_objects=['f0'])
+    self.RunCommand('setacl', ['private', suri(src_bucket_uri, '*')])
+
+  def testSetDefAclOnBucketRuns(self):
+    """Test that the setdefacl command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('setdefacl', ['private', suri(src_bucket_uri)])
+
+  def testSetDefAclOnObjectFails(self):
+    """Test that the setdefacl command fails when run against an object"""
+    src_bucket_uri = self.CreateBucket()
+    try:
+      self.RunCommand('setdefacl', ['private', suri(src_bucket_uri, '*')])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('URI must name a bucket', e.reason)
+
+  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, '*')).IterUris())
+    self.assertEqual(1, len(actual))
+    self.assertEqual('f0', actual[0].object_name)
+
+  def DownloadTestHelper(self, func):
+    """
+    Test resumable download with custom test function to distort downloaded
+    data. We expect an exception to be raised and the dest file to be removed.
+    """
+    object_uri = self.CreateObject()
+    dst_dir = self.CreateTempDir()
+    try:
+      self.RunCommand('cp', [suri(object_uri), dst_dir], test_method=func)
+      self.fail('Did not get expected CommandException')
+    except CommandException:
+      self.assertFalse(os.listdir(dst_dir))
+    except:
+      self.fail('Unexpected exception raised')
+
+  def testDownloadWithObjectSizeChange(self):
+    """
+    Test resumable download on an object that changes size before the
+    downloaded file's checksum is validated.
+    """
+    def append(fp):
+      """Append a byte at end of an open file and flush contents."""
+      fp.seek(0,2)
+      fp.write('x')
+      fp.flush()
+    self.DownloadTestHelper(append)
+
+  def testDownloadWithFileContentChange(self):
+    """
+    Tests resumable download on an object where the file content changes
+    before the downloaded file's checksum is validated.
+    """
+    def overwrite(fp):
+      """Overwrite first byte in an open file and flush contents."""
+      fp.seek(0)
+      fp.write('x')
+      fp.flush()
+    self.DownloadTestHelper(overwrite)
+
+  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, '**')).IterUris())
+    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)
+
+  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, '**')).IterUris())
+      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)
+
+  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()
+    x = ['-R', src_dir, suri(src_bucket_uri),
+               suri(dst_bucket_uri, 'dst_subdir')]
+    stdout = self.RunCommand(
+        'cp', x, return_stdout=True)
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'dst_subdir', 'f0'),
+                    suri(dst_bucket_uri, 'dst_subdir', 'nested', 'f1'),
+                    suri(dst_bucket_uri, 'dst_subdir', 'f2'),
+                    suri(dst_bucket_uri, 'dst_subdir', 'nested', 'f3')])
+    self.assertEqual(expected, actual)
+
+  def testCopyingBucketSubDirToDir(self):
+    """Tests copying a bucket subdir to a directory"""
+    src_bucket_uri = self.CreateBucket(test_objects=['src_subdir/obj'])
+    dst_dir = self.CreateTempDir()
+    # Test with and without final slash on dest subdir.
+    for (final_src_char, final_dst_char) in (
+        ('', ''), ('', '/'), ('/', ''), ('/', '/') ):
+      self.RunCommand(
+          'cp', ['-R', suri(src_bucket_uri, 'src_subdir') + final_src_char,
+                 dst_dir + final_dst_char])
+      actual = set(str(u) for u in self._test_wildcard_iterator(
+          '%s%s**' % (dst_dir, os.sep)).IterUris())
+      expected = set([suri(dst_dir, 'src_subdir', 'obj')])
+      self.assertEqual(expected, actual)
+
+  def testCopyingWildcardSpecifiedBucketSubDirToExistingDir(self):
+    """Tests copying a wildcard-specified bucket subdir to a directory"""
+    src_bucket_uri = self.CreateBucket(
+        test_objects=['src_sub0dir/foo', 'src_sub1dir/foo', 'src_sub2dir/foo',
+                      'src_sub3dir/foo'])
+    dst_dir = self.CreateTempDir()
+    # Test with and without final slash on dest subdir.
+    for i, (final_src_char, final_dst_char) in enumerate((
+        ('', ''), ('', '/'), ('/', ''), ('/', '/') )):
+      self.RunCommand(
+          'cp', ['-R', suri(src_bucket_uri, 'src_sub%d*' % i) + final_src_char,
+                 dst_dir + final_dst_char])
+      actual = set(str(u) for u in self._test_wildcard_iterator(
+          os.path.join(dst_dir, 'src_sub%ddir' % i, '**')).IterUris())
+      expected = set([suri(dst_dir, 'src_sub%ddir' % i, 'foo')])
+      self.assertEqual(expected, actual)
+
+  def testCopyingBucketSubDirToDirFailsWithoutMinusR(self):
+    """Tests for failure when attempting bucket subdir copy without -R"""
+    src_bucket_uri = self.CreateBucket(test_objects=['src_subdir/obj'])
+    dst_dir = self.CreateTempDir()
+    try:
+      self.RunCommand(
+          'cp', [suri(src_bucket_uri, 'src_subdir'), dst_dir])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('does not exist', e.reason)
+
+  def testCopyingBucketSubDirToBucketSubDir(self):
+    """Tests copying a bucket subdir to another bucket subdir"""
+    src_bucket_uri = self.CreateBucket(
+        test_objects=['src_subdir_%d/obj' % i for i in range(4)])
+    dst_bucket_uri = self.CreateBucket(
+        test_objects=['dst_subdir_%d/obj2' % i for i in range(4)])
+    # Test with and without final slash on dest subdir.
+    for i, (final_src_char, final_dst_char) in enumerate((
+        ('', ''), ('', '/'), ('/', ''), ('/', '/') )):
+      self.RunCommand(
+          'cp', ['-R', suri(src_bucket_uri, 'src_subdir_%d' % i) + final_src_char,
+                 suri(dst_bucket_uri, 'dst_subdir_%d' % i) + final_dst_char])
+      actual = set(str(u) for u in self._test_wildcard_iterator(
+          suri(dst_bucket_uri, 'dst_subdir_%d' % i, '**')).IterUris())
+      expected = set([suri(dst_bucket_uri, 'dst_subdir_%d' % i,
+                           'src_subdir_%d' % i, 'obj'),
+                      suri(dst_bucket_uri, 'dst_subdir_%d' % i, 'obj2')])
+      self.assertEqual(expected, actual)
+
+  def testCopyingBucketSubDirToBucketSubDirWithNested(self):
+    """Tests copying a bucket subdir to another bucket subdir with nesting."""
+    src_bucket_uri = self.CreateBucket(
+        test_objects=['src_subdir_%d/obj' % i for i in range(4)] +
+                     ['src_subdir_%d/nested/obj' % i for i in range(4)])
+    dst_bucket_uri = self.CreateBucket(
+        test_objects=['dst_subdir_%d/obj2' % i for i in range(4)])
+    # Test with and without final slash on dest subdir.
+    for i, (final_src_char, final_dst_char) in enumerate((
+        ('', ''), ('', '/'), ('/', ''), ('/', '/') )):
+      self.RunCommand(
+          'cp', ['-R', suri(src_bucket_uri, 'src_subdir_%d' % i) + final_src_char,
+                 suri(dst_bucket_uri, 'dst_subdir_%d' % i) + final_dst_char])
+      actual = set(str(u) for u in self._test_wildcard_iterator(
+          suri(dst_bucket_uri, 'dst_subdir_%d' % i, '**')).IterUris())
+      expected = set([suri(dst_bucket_uri, 'dst_subdir_%d' % i,
+                           'src_subdir_%d' % i, 'obj'),
+                      suri(dst_bucket_uri, 'dst_subdir_%d' % i,
+                           'src_subdir_%d' % i, 'nested', 'obj'),
+                      suri(dst_bucket_uri, 'dst_subdir_%d' % i, 'obj2')])
+      self.assertEqual(expected, actual)
+
+  def testMovingBucketSubDirToExistingBucketSubDir(self):
+    """Tests moving a bucket subdir to a existing bucket subdir"""
+    src_objs = ['foo']
+    for i in range(4):
+      src_objs.extend(['src_subdir%d/foo2' % i, 'src_subdir%d/nested/foo3' % i])
+    src_bucket_uri = self.CreateBucket(test_objects=src_objs)
+    dst_bucket_uri = self.CreateBucket(
+        test_objects=['dst_subdir%d/existing' % i for i in range(4)])
+    # Test with and without final slash on dest subdir.
+    for i, (final_src_char, final_dst_char) in enumerate((
+        ('', ''), ('', '/'), ('/', ''), ('/', '/') )):
+      self.RunCommand(
+          'mv', [suri(src_bucket_uri, 'src_subdir%d' % i) + final_src_char,
+                 suri(dst_bucket_uri, 'dst_subdir%d' % i) + final_dst_char])
+
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set()
+    for i in range(4):
+      expected.add(suri(dst_bucket_uri, 'dst_subdir%d' % i, 'existing'))
+      expected.add(suri(dst_bucket_uri, 'dst_subdir%d' % i, 'src_subdir%d' %i,
+                        'foo2'))
+      expected.add(suri(dst_bucket_uri, 'dst_subdir%d' % i, 'src_subdir%d' %i,
+                        'nested', 'foo3'))
+    self.assertEqual(expected, actual)
+
+  def testCopyingObjectToBucketSubDir(self):
+    """Tests copying an object to a bucket subdir"""
+    src_bucket_uri = self.CreateBucket(test_objects=['obj0'])
+    dst_bucket_uri = self.CreateBucket(test_objects=['dir0/existing',
+                                                     'dir1/existing'])
+    # Test with and without final slash on dest subdir.
+    for i, final_dst_char in enumerate(('', '/')):
+      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, '**')).IterUris())
+      expected = set([suri(dst_bucket_uri, 'dir%d' % i, 'obj0'),
+                      suri(dst_bucket_uri, 'dir%d' % i, 'existing')])
+      self.assertEqual(expected, actual)
+
+  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, '**')).IterUris())
+      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)
+
+  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(
+          suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([
+      suri(dst_bucket_uri, 'd0', 'placeholder'),
+      suri(dst_bucket_uri, 'd1', 'placeholder'),
+      suri(dst_bucket_uri, 'd0', 'd3', 'd4', 'nested', 'f1'),
+      suri(dst_bucket_uri, 'd1', 'd3', 'd4', 'nested', 'f1')])
+    self.assertEqual(expected, actual)
+
+  def testMovingWildcardedFilesToNonExistentBucketSubDir(self):
+    """Tests moving files to a non-existent bucket subdir"""
+    # This tests for how we allow users to do something like:
+    #   gsutil cp *.txt gs://bucket/dir
+    # where *.txt matches more than 1 file and gs://bucket/dir
+    # doesn't exist as a subdir.
+    #
+    src_bucket_uri = self.CreateBucket(test_objects=[
+        'f0f0', 'f0f1', 'f1f0', 'f1f1'])
+    dst_bucket_uri = self.CreateBucket(test_objects=[
+        'dst_subdir0/existing_obj', 'dst_subdir1/existing_obj'])
+    # Test with and without final slash on dest subdir.
+    for i, final_dst_char in enumerate(('', '/')):
+      # Copy some files into place in dst bucket.
+      self.RunCommand(
+          'cp', [suri(src_bucket_uri, 'f%df?' % i),
+                 suri(dst_bucket_uri, 'dst_subdir%d' % i) + final_dst_char])
+      # Now do the move test.
+      self.RunCommand(
+          'mv', [suri(src_bucket_uri, 'f%d*' % i),
+                 suri(dst_bucket_uri, 'nonexisting%d' % i) + final_dst_char])
+
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([
+      suri(dst_bucket_uri, 'dst_subdir0', 'existing_obj'),
+      suri(dst_bucket_uri, 'dst_subdir0', 'f0f0'),
+      suri(dst_bucket_uri, 'dst_subdir0', 'f0f1'),
+      suri(dst_bucket_uri, 'nonexisting0', 'f0f0'),
+      suri(dst_bucket_uri, 'nonexisting0', 'f0f1'),
+      suri(dst_bucket_uri, 'dst_subdir1', 'existing_obj'),
+      suri(dst_bucket_uri, 'dst_subdir1', 'f1f0'),
+      suri(dst_bucket_uri, 'dst_subdir1', 'f1f1'),
+      suri(dst_bucket_uri, 'nonexisting1', 'f1f0'),
+      suri(dst_bucket_uri, 'nonexisting1', 'f1f1')])
+    self.assertEqual(expected, actual)
+
+  def testMovingObjectToBucketSubDir(self):
+    """Tests moving an object to a bucket subdir"""
+    src_bucket_uri = self.CreateBucket(test_objects=['obj0', 'obj1'])
+    dst_bucket_uri = self.CreateBucket(test_objects=[
+        'dst_subdir0/existing_obj', 'dst_subdir1/existing_obj'])
+    # Test with and without final slash on dest subdir.
+    for i, final_dst_char in enumerate(('', '/')):
+      self.RunCommand(
+          'mv', [suri(src_bucket_uri, 'obj%d' % i),
+                 suri(dst_bucket_uri, 'dst_subdir%d' % i) + final_dst_char])
+
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([
+      suri(dst_bucket_uri, 'dst_subdir0', 'existing_obj'),
+      suri(dst_bucket_uri, 'dst_subdir0', 'obj0'),
+      suri(dst_bucket_uri, 'dst_subdir1', 'existing_obj'),
+      suri(dst_bucket_uri, 'dst_subdir1', 'obj1')])
+    self.assertEqual(expected, actual)
+
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(src_bucket_uri, '**')).IterUris())
+    self.assertEqual(actual, set())
+
+  def testWildcardSrcSubDirMoveDisallowed(self):
+    """Tests moving a bucket subdir specified by wildcard is disallowed"""
+    src_bucket_uri = self.CreateBucket(test_objects=['dir/foo1'])
+    dst_bucket_uri = self.CreateBucket(test_objects=['dir/foo2'])
+    try:
+      self.RunCommand(
+          'mv', [suri(src_bucket_uri, 'dir*'), suri(dst_bucket_uri, 'dir')])
+      self.fail('Did not get expected CommandException')
+    except CommandException, e:
+      self.assertIn('mv command disallows naming', e.reason)
+
+  def testMovingBucketSubDirToNonExistentBucketSubDir(self):
+    """Tests moving a bucket subdir to a non-existent bucket subdir"""
+    src_bucket = self.CreateBucket(test_objects=[
+        'foo', 'src_subdir0/foo2', 'src_subdir0/nested/foo3',
+        'src_subdir1/foo2', 'src_subdir1/nested/foo3'])
+    dst_bucket = self.CreateBucket()
+    # Test with and without final slash on dest subdir.
+    for i, final_src_char in enumerate(('', '/')):
+      self.RunCommand(
+          'mv', [suri(src_bucket, 'src_subdir%d' % i) + final_src_char,
+                 suri(dst_bucket, 'dst_subdir%d' % i)])
+
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket, '**')).IterUris())
+    # Unlike the case with copying, with mv we expect renaming to occur
+    # at the level of the src subdir, vs appending that subdir beneath the
+    # dst subdir like is done for copying.
+    expected = set([suri(dst_bucket, 'dst_subdir0', 'foo2'),
+                    suri(dst_bucket, 'dst_subdir1', 'foo2'),
+                    suri(dst_bucket, 'dst_subdir0', 'nested', 'foo3'),
+                    suri(dst_bucket, 'dst_subdir1', 'nested', 'foo3')])
+    self.assertEqual(expected, actual)
+
+  def testRemovingBucketSubDir(self):
+    """Tests removing a bucket subdir"""
+    dst_bucket_uri = self.CreateBucket(test_objects=[
+        'f0', 'dir0/f1', 'dir0/nested/f2', 'dir1/f1', 'dir1/nested/f2'])
+    # Test with and without final slash on dest subdir.
+    for i, final_src_char in enumerate(('', '/')):
+      # Test removing bucket subdir.
+      self.RunCommand(
+          'rm', ['-R', suri(dst_bucket_uri, 'dir%d' % i) + final_src_char])
+    actual = set(str(u) for u in self._test_wildcard_iterator(
+        suri(dst_bucket_uri, '**')).IterUris())
+    expected = set([suri(dst_bucket_uri, 'f0')])
+    self.assertEqual(expected, actual)
+
+  def testRecursiveRemoveObjsInBucket(self):
+    """Tests removing all objects in bucket via rm -R gs://bucket"""
+    bucket_uris = [
+        self.CreateBucket(test_objects=['f0', 'dir/f1', 'dir/nested/f2']),
+        self.CreateBucket(test_objects=['f0', 'dir/f1', 'dir/nested/f2'])]
+    # Test with and without final slash on dest subdir.
+    for i, final_src_char in enumerate(('', '/')):
+      # Test removing all objects via rm -R.
+      self.RunCommand('rm', ['-R', suri(bucket_uris[i]) + final_src_char])
+      actual = set(str(u) for u in self._test_wildcard_iterator(
+          suri(bucket_uris[i], '**')).IterUris())
+      self.assertEqual(actual, set())
+
+  def FinalObjNameComponent(self, uri):
+    """For gs://bucket/abc/def/ghi returns ghi."""
+    return uri.uri.rpartition('/')[-1]
+
+
+# TODO: These should all be moved to their own test_*.py testing files.
+class GsUtilCommandTests(testcase.GsUtilUnitTestCase):
+  """Basic sanity check tests to make sure commands run."""
+
+  def testDisableLoggingCommandRuns(self):
+    """Test that the disablelogging command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('disablelogging', [suri(src_bucket_uri)])
+
+  def testEnableLoggingCommandRuns(self):
+    """Test that the enablelogging command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('enablelogging', ['-b', 'gs://log_bucket',
+                                      suri(src_bucket_uri)])
+
+  def testHelpCommandDoesntRaise(self):
+    """Test that the help command doesn't raise (sanity checks all help)"""
+    # Unset PAGER if defined, so help output paginating into $PAGER doesn't
+    # cause test to pause.
+    if 'PAGER' in os.environ:
+      del os.environ['PAGER']
+    self.RunCommand('help', [])
+
+  def testCatCommandRuns(self):
+    """Test that the cat command basically runs"""
+    src_uri = self.CreateObject(contents='foo')
+    stdout = self.RunCommand('cat', [suri(src_uri)], return_stdout=True)
+    self.assertEqual(stdout, 'foo')
+
+  def testGetAclCommandRuns(self):
+    """Test that the getacl command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('getacl', [suri(src_bucket_uri)])
+
+  def testGetDefAclCommandRuns(self):
+    """Test that the getdefacl command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('getacl', [suri(src_bucket_uri)])
+
+  def testGetLoggingCommandRuns(self):
+    """Test that the getlogging command basically runs"""
+    src_bucket_uri = self.CreateBucket()
+    self.RunCommand('getlogging', [suri(src_bucket_uri)])
+
+  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 boto.exception.StorageCreateError, 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://non_existent_%s' % dst_bucket_uri.bucket_name])
+      self.fail('Did not get expected StorageResponseError')
+    except boto.exception.StorageResponseError, 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 WildcardException')
+    except StorageResponseError, e:
+      self.assertIn('Not Found', 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', [])