gcloud 0.0.7 → 0.1.0

data/packages/gsutil/gslib/plurality_checkable_iterator.py

@@ -1,56 +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.
-
-"""
-Iterator wrapper that allows you to check whether the wrapped iterator
-is empty and whether it has more than 1 element.
-"""
-
-class PluralityCheckableIterator(object):
-
-  def __init__(self, it):
-    self.it = it.__iter__()
-    self.head = []
-    # Populate first 2 elems into head so we can check whether iterator has
-    # more than 1 item.
-    for i in range(0, 2):
-      self.__populate_head__()
-
-  def __populate_head__(self):
-    try:
-      e = self.it.next()
-      self.underlying_iter_empty = False
-      self.head.append(e)
-    except StopIteration:
-      # Indicates we can no longer call next() on underlying iterator, but
-      # there could still be elements left to iterate in head.
-      self.underlying_iter_empty = True
-
-  def __iter__(self):
-    while len(self.head) > 0:
-      yield self.next()
-    else:
-      raise StopIteration()
-
-  def next(self):
-    # Backfill into head each time we pop an element so we can always check
-    # for emptiness and for has_plurality().
-    self.__populate_head__()
-    return self.head.pop(0)
-
-  def is_empty(self):
-    return len(self.head) == 0
-
-  def has_plurality(self):
-    return len(self.head) > 1

data/packages/gsutil/gslib/project_id.py

@@ -1,67 +0,0 @@
-# Copyright 2011 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
-
-from gslib.exception import ProjectIdException
-from gslib.wildcard_iterator import WILDCARD_BUCKET_ITERATOR
-
-GOOG_PROJ_ID_HDR = 'x-goog-project-id'
-
-
-class ProjectIdHandler(object):
-  """Google Project ID header handling."""
-
-  def __init__(self):
-    """Instantiates Project ID handler. Call after boto config file loaded."""
-    config = boto.config
-    self.project_id = config.get_value('GSUtil', 'default_project_id')
-
-  def SetProjectId(self, project_id):
-    """Overrides project ID value from config file default.
-
-    Args:
-      project_id: Project ID to use.
-    """
-    self.project_id = project_id
-
-  def FillInProjectHeaderIfNeeded(self, command, uri, headers):
-    """Fills project ID header into headers if defined and applicable.
-
-    Args:
-      command: The command being run.
-      uri: The URI against which this command is being run.
-      headers: Dictionary containing optional HTTP headers to pass to boto.
-          Must not be None.
-    """
-
-    # We only include the project ID header if it's a GS URI and a project_id
-    # was specified and
-    # (it's an 'mb', 'disablelogging, or 'enablelogging' command or
-    #  a boto request in integration tests or
-    #  (an 'ls' command that doesn't specify a bucket or wildcarded bucket)).
-    if (uri.scheme.lower() == 'gs' and self.project_id
-        and (command == 'mb' or command == 'disablelogging'
-             or command == 'enablelogging'
-             or command == 'test'
-             or (command == 'ls' and not uri.names_bucket())
-             or (command == WILDCARD_BUCKET_ITERATOR))):
-      # Note: check for None (as opposed to "not headers") here because
-      # it's ok to pass empty headers.
-      if headers is None:
-        raise ProjectIdException(
-            'FillInProjectHeaderIfNeeded called with headers=None')
-      headers[GOOG_PROJ_ID_HDR] = self.project_id
-    elif headers.has_key(GOOG_PROJ_ID_HDR):
-      del headers[GOOG_PROJ_ID_HDR]

data/packages/gsutil/gslib/storage_uri_builder.py

@@ -1,56 +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.
-
-"""
-Class that holds state (bucket_storage_uri_class and debug) needed for
-instantiating StorageUri objects. The StorageUri func defined in this class
-uses that state plus gsutil default flag values to instantiate this frequently
-constructed object with just one param for most cases.
-"""
-
-import boto
-from gslib.exception import CommandException
-
-
-class StorageUriBuilder(object):
-
-  def __init__(self, debug, bucket_storage_uri_class):
-    """
-    Args:
-      debug: Debug level to pass in to boto connection (range 0..3).
-      bucket_storage_uri_class: Class to instantiate for cloud StorageUris.
-                                Settable for testing/mocking.
-    """
-    self.bucket_storage_uri_class = bucket_storage_uri_class
-    self.debug = debug
-
-  def StorageUri(self, uri_str, is_latest=False):
-    """
-    Instantiates StorageUri using class state and gsutil default flag values.
-
-    Args:
-      uri_str: StorageUri naming bucket or object.
-      is_latest: boolean indicating whether this versioned object represents the
-          current version.
-
-    Returns:
-      boto.StorageUri for given uri_str.
-
-    Raises:
-      InvalidUriError: if uri_str not valid.
-    """
-    return boto.storage_uri(
-        uri_str, 'file', debug=self.debug, validate=False,
-        bucket_storage_uri_class=self.bucket_storage_uri_class,
-        suppress_consec_slashes=False, is_latest=is_latest)

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

@@ -1,236 +0,0 @@
-# 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 time
-
-from gslib.command import _ThreadedLogger as ThreadedLogger
-import gslib.commands.chacl as chacl
-import gslib.tests.testcase as case
-from gslib.tests.util import ObjectToURI as suri
-
-
-class ChaclIntegrationTest(case.GsUtilIntegrationTestCase):
-  """Tests gslib.commands.chacl."""
-  logger = ThreadedLogger()
-
-  def setUp(self):
-    super(ChaclIntegrationTest, self).setUp()
-    self.sample_uri = self.CreateBucket()
-    self.logger = ThreadedLogger()
-
-  def testAclChangeWithUserId(self):
-    change = chacl.AclChange(self.USER_TEST_ID + ':r',
-                             scope_type=chacl.ChangeType.USER,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'UserById', self.USER_TEST_ID)
-
-  def testAclChangeWithGroupId(self):
-    change = chacl.AclChange(self.GROUP_TEST_ID + ':r',
-                             scope_type=chacl.ChangeType.GROUP,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'GroupById', self.GROUP_TEST_ID)
-
-  def testAclChangeWithUserEmail(self):
-    change = chacl.AclChange(self.USER_TEST_ADDRESS + ':r',
-                             scope_type=chacl.ChangeType.USER,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'UserByEmail', self.USER_TEST_ADDRESS)
-
-  def testAclChangeWithGroupEmail(self):
-    change = chacl.AclChange(self.GROUP_TEST_ADDRESS + ':fc',
-                             scope_type=chacl.ChangeType.GROUP,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'FULL_CONTROL', 'GroupByEmail',
-                    self.GROUP_TEST_ADDRESS)
-
-  def testAclChangeWithDomain(self):
-    change = chacl.AclChange(self.DOMAIN_TEST + ':READ',
-                             scope_type=chacl.ChangeType.GROUP,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'GroupByDomain', self.DOMAIN_TEST)
-
-  def testAclChangeWithAllUsers(self):
-    change = chacl.AclChange('AllUsers:WRITE',
-                             scope_type=chacl.ChangeType.GROUP,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'WRITE', 'AllUsers')
-
-  def testAclChangeWithAllAuthUsers(self):
-    change = chacl.AclChange('AllAuthenticatedUsers:READ',
-                             scope_type=chacl.ChangeType.GROUP,
-                             logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    change.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'AllAuthenticatedUsers')
-
-  def testAclDelWithUser(self):
-    add = chacl.AclChange(self.USER_TEST_ADDRESS + ':READ',
-                          scope_type=chacl.ChangeType.USER,
-                          logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    add.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'UserByEmail', self.USER_TEST_ADDRESS)
-
-    remove = chacl.AclDel(self.USER_TEST_ADDRESS,
-                          logger=self.logger)
-    remove.Execute(self.sample_uri, acl)
-    self._AssertHasNo(acl, 'READ', 'UserByEmail', self.USER_TEST_ADDRESS)
-
-  def testAclDelWithGroup(self):
-    add = chacl.AclChange(self.USER_TEST_ADDRESS + ':READ',
-                          scope_type=chacl.ChangeType.GROUP,
-                          logger=self.logger)
-    acl = self.sample_uri.get_acl()
-    add.Execute(self.sample_uri, acl)
-    self._AssertHas(acl, 'READ', 'GroupByEmail', self.USER_TEST_ADDRESS)
-
-    remove = chacl.AclDel(self.USER_TEST_ADDRESS,
-                          logger=self.logger)
-    remove.Execute(self.sample_uri, acl)
-    self._AssertHasNo(acl, 'READ', 'GroupByEmail', self.GROUP_TEST_ADDRESS)
-
-  #
-  # Here are a whole lot of verbose asserts
-  #
-
-  def _AssertHas(self, current_acl, perm, scope, value=None):
-    matches = list(self._YieldMatchingEntries(current_acl, perm, scope, value))
-    self.assertEqual(1, len(matches))
-
-  def _AssertHasNo(self, current_acl, perm, scope, value=None):
-    matches = list(self._YieldMatchingEntries(current_acl, perm, scope, value))
-    self.assertEqual(0, len(matches))
-
-  def _YieldMatchingEntries(self, current_acl, perm, scope, value=None):
-    """Generator that finds entries that match the change descriptor."""
-    for entry in current_acl.entries.entry_list:
-      if entry.scope.type == scope:
-        if scope in ['UserById', 'GroupById']:
-          if value == entry.scope.id:
-            yield entry
-        elif scope in ['UserByEmail', 'GroupByEmail']:
-          if value == entry.scope.email_address:
-            yield entry
-        elif scope == 'GroupByDomain':
-          if value == entry.scope.domain:
-            yield entry
-        elif scope in ['AllUsers', 'AllAuthenticatedUsers']:
-          yield entry
-        else:
-          raise CommandException('Found an unrecognized ACL '
-                                 'entry type, aborting.')
-
-  def _MakeScopeRegex(self, scope_type, email_address, perm):
-    template_regex = (
-        r'<Scope type="{0}">\s*<EmailAddress>\s*{1}\s*</EmailAddress>\s*'
-        r'</Scope>\s*<Permission>\s*{2}\s*</Permission>')
-    return template_regex.format(scope_type, email_address, perm)
-
-  def testBucketAclChange(self):
-    test_regex = self._MakeScopeRegex(
-        'UserByEmail', self.USER_TEST_ADDRESS, 'FULL_CONTROL')
-    xml = self.RunGsUtil(
-        ['getacl', suri(self.sample_uri)], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)
-
-    self.RunGsUtil(
-        ['chacl', '-u', self.USER_TEST_ADDRESS+':fc', suri(self.sample_uri)])
-    xml = self.RunGsUtil(
-        ['getacl', suri(self.sample_uri)], return_stdout=True)
-    self.assertRegexpMatches(xml, test_regex)
-
-    self.RunGsUtil(
-        ['chacl', '-d', self.USER_TEST_ADDRESS, suri(self.sample_uri)])
-    xml = self.RunGsUtil(
-        ['getacl', suri(self.sample_uri)], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)
-
-  def testObjectAclChange(self):
-    obj = self.CreateObject(bucket_uri=self.sample_uri, contents='something')
-    test_regex = self._MakeScopeRegex(
-        'GroupByEmail', self.GROUP_TEST_ADDRESS, 'READ')
-    xml = self.RunGsUtil(['getacl', suri(obj)], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)
-
-    self.RunGsUtil(['chacl', '-g', self.GROUP_TEST_ADDRESS+':READ', suri(obj)])
-    xml = self.RunGsUtil(['getacl', suri(obj)], return_stdout=True)
-    self.assertRegexpMatches(xml, test_regex)
-
-    self.RunGsUtil(['chacl', '-d', self.GROUP_TEST_ADDRESS, suri(obj)])
-    xml = self.RunGsUtil(['getacl', suri(obj)], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)
-
-  def testMultithreadedAclChange(self, count=10):
-    objects = []
-    for i in range(count):
-      objects.append(self.CreateObject(
-          bucket_uri=self.sample_uri,
-          contents='something {0}'.format(i)))
-
-    test_regex = self._MakeScopeRegex(
-        'GroupByEmail', self.GROUP_TEST_ADDRESS, 'READ')
-    xmls = []
-    for obj in objects:
-      xmls.append(self.RunGsUtil(['getacl', suri(obj)], return_stdout=True))
-    for xml in xmls:
-      self.assertNotRegexpMatches(xml, test_regex)
-
-    uris = [suri(obj) for obj in objects]
-    self.RunGsUtil(['-m', '-DD', 'chacl', '-g',
-                    self.GROUP_TEST_ADDRESS+':READ'] + uris)
-
-    xmls = []
-    for obj in objects:
-      xmls.append(self.RunGsUtil(['getacl', suri(obj)], return_stdout=True))
-    for xml in xmls:
-      self.assertRegexpMatches(xml, test_regex)
-
-  def testMultiVersionSupport(self):
-    bucket = self.CreateVersionedBucket()
-    object_name = self.MakeTempName('obj')
-    obj = self.CreateObject(
-        bucket_uri=bucket, object_name=object_name, contents='One thing')
-    # Create another on the same URI, giving us a second version.
-    self.CreateObject(
-        bucket_uri=bucket, object_name=object_name, contents='Another thing')
-    # Bucket listings are eventually consistent, so wait to increase the likelihood 
-    # we'll see both versions of the object we just created. 
-    time.sleep(0.5)
-    stdout = self.RunGsUtil(['ls', '-a', suri(obj)], return_stdout=True)
-    obj_v1, obj_v2 = stdout.strip().split('\n')
-
-    test_regex = self._MakeScopeRegex(
-        'GroupByEmail', self.GROUP_TEST_ADDRESS, 'READ')
-    xml = self.RunGsUtil(['getacl', obj_v1], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)
-
-    self.RunGsUtil(['chacl', '-g', self.GROUP_TEST_ADDRESS+':READ', obj_v1])
-    xml = self.RunGsUtil(['getacl', obj_v1], return_stdout=True)
-    self.assertRegexpMatches(xml, test_regex)
-
-    xml = self.RunGsUtil(['getacl', obj_v2], return_stdout=True)
-    self.assertNotRegexpMatches(xml, test_regex)

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

@@ -1,267 +0,0 @@
-# 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)