gcloud 0.0.7 → 0.1.0

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

@@ -1,41 +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 gslib.tests.testcase as testcase
-from gslib.tests.util import ObjectToURI as suri
-
-
-class TestPerfDiag(testcase.GsUtilIntegrationTestCase):
-  """Integration tests for perfdiag command."""
-
-  def test_latency(self):
-    bucket_uri = self.CreateBucket()
-    self.RunGsUtil(['perfdiag', '-n', '1', '-t', 'lat', suri(bucket_uri)])
-
-  def test_write_throughput(self):
-    bucket_uri = self.CreateBucket()
-    self.RunGsUtil(['perfdiag', '-n', '1', '-s', '1024', '-t', 'wthru',
-                    suri(bucket_uri)])
-
-  def test_read_throughput(self):
-    bucket_uri = self.CreateBucket()
-    self.RunGsUtil(['perfdiag', '-n', '1', '-s', '1024', '-t', 'rthru',
-                    suri(bucket_uri)])
-
-  def test_input_output(self):
-    outpath = self.CreateTempFile()
-    bucket_uri = self.CreateBucket()
-    self.RunGsUtil(['perfdiag', '-o', outpath, '-n', '1', '-t', 'lat',
-                    suri(bucket_uri)])
-    self.RunGsUtil(['perfdiag', '-i', outpath])

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

@@ -1,67 +0,0 @@
-# Copyright 2012 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.
-
-"""Unit tests for PluralityCheckableIterator"""
-
-from gslib.plurality_checkable_iterator import PluralityCheckableIterator
-import gslib.tests.testcase as testcase
-
-class PluralityCheckableIteratorTests(testcase.GsUtilUnitTestCase):
-
-  def testPluralityCheckableIteratorWith0Elems(self):
-    """Tests empty PluralityCheckableIterator."""
-    input_list = range(0)
-    it = iter(input_list)
-    pcit = PluralityCheckableIterator(it)
-    self.assertTrue(pcit.is_empty())
-    self.assertFalse(pcit.has_plurality())
-    output_list = list(pcit)
-    self.assertEqual(input_list, output_list)
-
-  def testPluralityCheckableIteratorWith1Elem(self):
-    """Tests PluralityCheckableIterator with 1 element."""
-    input_list = range(1)
-    it = iter(input_list)
-    pcit = PluralityCheckableIterator(it)
-    self.assertFalse(pcit.is_empty())
-    self.assertFalse(pcit.has_plurality())
-    output_list = list(pcit)
-    self.assertEqual(input_list, output_list)
-
-  def testPluralityCheckableIteratorWith2Elems(self):
-    """Tests PluralityCheckableIterator with 2 elements."""
-    input_list = range(2)
-    it = iter(input_list)
-    pcit = PluralityCheckableIterator(it)
-    self.assertFalse(pcit.is_empty())
-    self.assertTrue(pcit.has_plurality())
-    output_list = list(pcit)
-    self.assertEqual(input_list, output_list)
-
-  def testPluralityCheckableIteratorWith3Elems(self):
-    """Tests PluralityCheckableIterator with 3 elements."""
-    input_list = range(3)
-    it = iter(input_list)
-    pcit = PluralityCheckableIterator(it)
-    self.assertFalse(pcit.is_empty())
-    self.assertTrue(pcit.has_plurality())
-    output_list = list(pcit)
-    self.assertEqual(input_list, output_list)

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

@@ -1,143 +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 gslib.tests.testcase as testcase
-from gslib.tests.util import ObjectToURI as suri
-
-
-class TestRm(testcase.GsUtilIntegrationTestCase):
-  """Integration tests for rm command."""
-
-  def test_all_versions_current(self):
-    """Test that 'rm -a' for an object with a current version works."""
-    bucket_uri = self.CreateVersionedBucket()
-    key_uri = bucket_uri.clone_replace_name('foo')
-    key_uri.set_contents_from_string('bar')
-    g1 = key_uri.generation
-    key_uri.set_contents_from_string('baz')
-    g2 = key_uri.generation
-    stderr = self.RunGsUtil(['-m', 'rm', '-a', suri(key_uri)],
-                            return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 2)
-    self.assertIn('Removing %s#%s...' % (suri(key_uri), g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(key_uri), g2), stderr)
-    stdout = self.RunGsUtil(['ls', '-a', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')
-
-  def test_all_versions_no_current(self):
-    """Test that 'rm -a' for an object without a current version works."""
-    bucket_uri = self.CreateVersionedBucket()
-    key_uri = bucket_uri.clone_replace_name('foo')
-    key_uri.set_contents_from_string('bar')
-    g1 = key_uri.generation
-    key_uri.set_contents_from_string('baz')
-    g2 = key_uri.generation
-    stderr = self.RunGsUtil(['rm', suri(key_uri)], return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 1)
-    self.assertIn('Removing %s...' % suri(key_uri), stderr)
-    stderr = self.RunGsUtil(['-m', 'rm', '-a', suri(key_uri)], 
-                            return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 2)
-    self.assertIn('Removing %s#%s...' % (suri(key_uri), g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(key_uri), g2), stderr)
-    stdout = self.RunGsUtil(['ls', '-a', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')
-
-  def test_fails_for_missing_obj(self):
-    bucket_uri = self.CreateVersionedBucket()
-    stderr = self.RunGsUtil(['rm', '-a', '%s/foo' % suri(bucket_uri)],
-                            return_stderr=True, expected_status=1)
-    self.assertIn('Not Found', stderr)
-
-  def test_remove_all_versions_recursive_on_bucket(self):
-    """Test that 'rm -ar' works on bucket."""
-    bucket_uri = self.CreateVersionedBucket()
-    k1_uri = bucket_uri.clone_replace_name('foo')
-    k2_uri = bucket_uri.clone_replace_name('foo2')
-    k1_uri.set_contents_from_string('bar')
-    k2_uri.set_contents_from_string('bar2')
-    k1g1 = k1_uri.generation
-    k2g1 = k2_uri.generation
-    k1_uri.set_contents_from_string('baz')
-    k2_uri.set_contents_from_string('baz2')
-    k1g2 = k1_uri.generation
-    k2g2 = k2_uri.generation
-
-    stderr = self.RunGsUtil(['rm', '-ar', suri(bucket_uri)], return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 4)
-    self.assertIn('Removing %s#%s...' % (suri(k1_uri), k1g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k1_uri), k1g2), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k2_uri), k2g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k2_uri), k2g2), stderr)
-    stdout = self.RunGsUtil(['ls', '-a', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')
-
-  def test_remove_all_versions_recursive_on_subdir(self):
-    """Test that 'rm -ar' works on subdir."""
-    bucket_uri = self.CreateVersionedBucket()
-    k1_uri = bucket_uri.clone_replace_name('dir/foo')
-    k2_uri = bucket_uri.clone_replace_name('dir/foo2')
-    k1_uri.set_contents_from_string('bar')
-    k2_uri.set_contents_from_string('bar2')
-    k1g1 = k1_uri.generation
-    k2g1 = k2_uri.generation
-    k1_uri.set_contents_from_string('baz')
-    k2_uri.set_contents_from_string('baz2')
-    k1g2 = k1_uri.generation
-    k2g2 = k2_uri.generation
-
-    stderr = self.RunGsUtil(['rm', '-ar', '%s/dir' % suri(bucket_uri)],
-                            return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 4)
-    self.assertIn('Removing %s#%s...' % (suri(k1_uri), k1g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k1_uri), k1g2), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k2_uri), k2g1), stderr)
-    self.assertIn('Removing %s#%s...' % (suri(k2_uri), k2g2), stderr)
-    stdout = self.RunGsUtil(['ls', '-a', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')
-
-  def test_some_missing(self):
-    """Test that 'rm -a' fails when some but not all uris don't exist."""
-    bucket_uri = self.CreateVersionedBucket()
-    key_uri = bucket_uri.clone_replace_name('foo')
-    key_uri.set_contents_from_string('bar')
-    stderr = self.RunGsUtil(['rm', '-a', suri(key_uri), '%s/missing'
-                            % suri(bucket_uri)],
-                            return_stderr=True, expected_status=1)
-    self.assertEqual(stderr.count('Removing gs://'), 2)
-    self.assertIn('Not Found', stderr)
-
-  def test_some_missing_force(self):
-    """Test that 'rm -af' succeeds despite hidden first uri."""
-    bucket_uri = self.CreateVersionedBucket()
-    key_uri = bucket_uri.clone_replace_name('foo')
-    key_uri.set_contents_from_string('bar')
-    stderr = self.RunGsUtil(['rm', '-af', suri(key_uri), '%s/missing'
-                            % suri(bucket_uri)], return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 2)
-    stdout = self.RunGsUtil(['ls', '-a', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')
-
-  def test_folder_objects_deleted(self):
-    """Test for 'rm -r' of a folder with a dir_$folder$ marker."""
-    bucket_uri = self.CreateVersionedBucket()
-    key_uri = bucket_uri.clone_replace_name('abc/o1')
-    key_uri.set_contents_from_string('foobar')
-    folderkey = bucket_uri.clone_replace_name('abc_$folder$')
-    folderkey.set_contents_from_string('')
-    stderr = self.RunGsUtil(['rm', '-r', '%s/abc' % suri(bucket_uri)],
-                            return_stderr=True)
-    self.assertEqual(stderr.count('Removing gs://'), 2)
-    stdout = self.RunGsUtil(['ls', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, '')

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

@@ -1,152 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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.
-"""Integration tests for the setacl and setdefacl commands."""
-
-import gslib.tests.testcase as testcase
-import os
-import re
-from gslib.tests.util import ObjectToURI as suri
-
-PUBLIC_READ_ACL_TEXT = '<Scope type="AllUsers"/><Permission>READ</Permission>'
-
-
-class TestSetAcl(testcase.GsUtilIntegrationTestCase):
-  """Integration tests for setacl command."""
-
-  def test_set_invalid_acl_object(self):
-    """Ensures that invalid XML content returns a MalformedACLError."""
-    obj_uri = suri(self.CreateObject(contents='foo'))
-    inpath = self.CreateTempFile(contents='badXml')
-    stderr = self.RunGsUtil(['setacl', inpath, obj_uri], return_stderr=True,
-                            expected_status=1)
-
-    self.assertIn('MalformedACLError', stderr)
-
-  def test_set_invalid_acl_bucket(self):
-    """Ensures that invalid XML content returns a MalformedACLError."""
-    bucket_uri = suri(self.CreateBucket())
-    inpath = self.CreateTempFile(contents='badXml')
-    stderr = self.RunGsUtil(['setacl', inpath, bucket_uri], return_stderr=True,
-                            expected_status=1)
-
-    self.assertIn('MalformedACLError', stderr)
-
-  def test_set_valid_acl_object(self):
-    """Ensures that valid canned and XML ACLs work with get/set."""
-    obj_uri = suri(self.CreateObject(contents='foo'))
-    acl_string = self.RunGsUtil(['getacl', obj_uri], return_stdout=True)
-    inpath = self.CreateTempFile(contents=acl_string)
-    self.RunGsUtil(['setacl', 'public-read', obj_uri])
-    acl_string2 = self.RunGsUtil(['getacl', obj_uri], return_stdout=True)
-    self.RunGsUtil(['setacl', inpath, obj_uri])
-    acl_string3 = self.RunGsUtil(['getacl', obj_uri], return_stdout=True)
-
-    self.assertNotEqual(acl_string, acl_string2)
-    self.assertEqual(acl_string, acl_string3)
-
-  def test_set_valid_permission_whitespace_object(self):
-    """Ensures that whitespace is allowed in <Permission> elements."""
-    obj_uri = suri(self.CreateObject(contents='foo'))
-    acl_string = self.RunGsUtil(['getacl', obj_uri], return_stdout=True)
-    acl_string = re.sub(r'<Permission>', r'<Permission> \n', acl_string)
-    acl_string = re.sub(r'</Permission>', r'\n </Permission>', acl_string)
-    inpath = self.CreateTempFile(contents=acl_string)
-    self.RunGsUtil(['setacl', inpath, obj_uri])
-
-  def test_set_valid_acl_bucket(self):
-    """Ensures that valid canned and XML ACLs work with get/set."""
-    bucket_uri = suri(self.CreateBucket())
-    acl_string = self.RunGsUtil(['getacl', bucket_uri], return_stdout=True)
-    inpath = self.CreateTempFile(contents=acl_string)
-    self.RunGsUtil(['setacl', 'public-read', bucket_uri])
-    acl_string2 = self.RunGsUtil(['getacl', bucket_uri], return_stdout=True)
-    self.RunGsUtil(['setacl', inpath, bucket_uri])
-    acl_string3 = self.RunGsUtil(['getacl', bucket_uri], return_stdout=True)
-
-    self.assertNotEqual(acl_string, acl_string2)
-    self.assertEqual(acl_string, acl_string3)
-
-  def test_invalid_canned_acl_object(self):
-    """Ensures that an invalid canned ACL returns a CommandException."""
-    obj_uri = suri(self.CreateObject(contents='foo'))
-    stderr = self.RunGsUtil(['setacl', 'not-a-canned-acl',
-                             obj_uri], return_stderr=True, expected_status=1)
-    self.assertIn('CommandException', stderr)
-    self.assertIn('Invalid canned ACL', stderr)
-
-  def test_set_valid_def_acl_bucket(self):
-    """Ensures that valid default canned and XML ACLs works with get/set."""
-    bucket_uri = self.CreateBucket()
-
-    # Default ACL is project private.
-    obj_uri1 = suri(self.CreateObject(bucket_uri=bucket_uri, contents='foo'))
-    acl_string = self.RunGsUtil(['getacl', obj_uri1], return_stdout=True)
-
-    # Change it to authenticated-read.
-    self.RunGsUtil(['setdefacl', 'authenticated-read', suri(bucket_uri)])
-    obj_uri2 = suri(self.CreateObject(bucket_uri=bucket_uri, contents='foo2'))
-    acl_string2 = self.RunGsUtil(['getacl', obj_uri2], return_stdout=True)
-
-    # Now change it back to the default via XML.
-    inpath = self.CreateTempFile(contents=acl_string)
-    self.RunGsUtil(['setdefacl', inpath, suri(bucket_uri)])
-    obj_uri3 = suri(self.CreateObject(bucket_uri=bucket_uri, contents='foo3'))
-    acl_string3 = self.RunGsUtil(['getacl', obj_uri3], return_stdout=True)
-
-    self.assertNotEqual(acl_string, acl_string2)
-    self.assertIn('AllAuthenticatedUsers', acl_string2)
-    self.assertEqual(acl_string, acl_string3)
-
-  def test_setacl_version_specific_uri(self):
-    bucket_uri = self.CreateVersionedBucket()
-    # Create initial object version.
-    uri = self.CreateObject(bucket_uri=bucket_uri, contents='data')
-    # Create a second object version.
-    inpath = self.CreateTempFile(contents='def')
-    self.RunGsUtil(['cp', inpath, uri.uri])
-
-    # Find out the two object version IDs.
-    stdout = self.RunGsUtil(['ls', '-a', uri.uri], return_stdout=True)
-    lines = stdout.split('\n')
-    # There should be 3 lines, counting final \n.
-    self.assertEqual(len(lines), 3)
-    v0_uri_str = lines[0]
-    v1_uri_str = lines[1]
-
-    # Check that neither version currently has public-read permission
-    # (default ACL is project-private).
-    orig_acls = []
-    for uri_str in (v0_uri_str, v1_uri_str):
-      acl = self.RunGsUtil(['getacl', uri_str], return_stdout=True)
-      self.assertNotIn(PUBLIC_READ_ACL_TEXT, self._strip_xml_whitespace(acl))
-      orig_acls.append(acl)
-
-    # Set the ACL for the older version of the object to public-read.
-    self.RunGsUtil(['setacl', 'public-read', v0_uri_str])
-    # Check that the older version's ACL is public-read, but newer version
-    # is not.
-    acl = self.RunGsUtil(['getacl', v0_uri_str], return_stdout=True)
-    self.assertIn(PUBLIC_READ_ACL_TEXT, self._strip_xml_whitespace(acl))
-    acl = self.RunGsUtil(['getacl', v1_uri_str], return_stdout=True)
-    self.assertNotIn(PUBLIC_READ_ACL_TEXT, self._strip_xml_whitespace(acl))
-
-    # Check that reading the ACL with the version-less URI returns the
-    # original ACL (since the version-less URI means the current version).
-    acl = self.RunGsUtil(['getacl', uri.uri], return_stdout=True)
-    self.assertEqual(acl, orig_acls[0])
-
-  def _strip_xml_whitespace(self, xml):
-    s = re.sub('>\s*', '>', xml.replace('\n', ''))
-    return re.sub('\s*<', '<', s)

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

@@ -1,168 +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 posixpath
-from xml.dom.minidom import parseString
-
-import gslib.tests.testcase as testcase
-from gslib.tests.util import ObjectToURI as suri
-
-
-class TestSetCors(testcase.GsUtilIntegrationTestCase):
-  """Integration tests for setcors command."""
-
-  empty_doc1 = parseString('<CorsConfig/>').toprettyxml(indent='    ')
-
-  empty_doc2 = parseString(
-      '<CorsConfig></CorsConfig>').toprettyxml(indent='    ')
-
-  empty_doc3 = parseString(
-      '<CorsConfig><Cors/></CorsConfig>').toprettyxml(indent='    ')
-
-  empty_doc4 = parseString(
-      '<CorsConfig><Cors></Cors></CorsConfig>').toprettyxml(indent='    ')
-
-  cors_bad1 = ('<?xml version="1.0" ?><CorsConfig><Cors><Methods><Method>GET'
-               '</ResponseHeader></Methods></Cors></CorsConfig>')
-
-  cors_bad2 = ('<?xml version="1.0" ?><CorsConfig><Cors><Methods><Cors>GET'
-               '</Cors></Methods></Cors></CorsConfig>')
-
-  cors_bad3 = ('<?xml version="1.0" ?><CorsConfig><Methods><Method>GET'
-               '</Method></Methods></Cors></CorsConfig>')
-
-  cors_bad4 = ('<?xml version="1.0" ?><CorsConfig><Cors><Method>GET'
-               '</Method></Cors></CorsConfig>')
-
-  cors_doc = parseString(
-      '<CorsConfig><Cors><Origins>'
-      '<Origin>http://origin1.example.com</Origin>'
-      '<Origin>http://origin2.example.com</Origin>'
-      '</Origins><Methods><Method>GET</Method>'
-      '<Method>PUT</Method><Method>POST</Method></Methods>'
-      '<ResponseHeaders><ResponseHeader>foo</ResponseHeader>'
-      '<ResponseHeader>bar</ResponseHeader></ResponseHeaders>'
-      '<MaxAgeSec>3600</MaxAgeSec></Cors>'
-      '<Cors><Origins><Origin>http://origin3.example.com</Origin></Origins>'
-      '<Methods><Method>GET</Method><Method>DELETE</Method></Methods>'
-      '<ResponseHeaders><ResponseHeader>foo2</ResponseHeader>'
-      '<ResponseHeader>bar2</ResponseHeader></ResponseHeaders>'
-      '</Cors></CorsConfig>').toprettyxml(indent='    ')
-
-  def test_default_cors(self):
-    bucket_uri = self.CreateBucket()
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc1)
-
-  def test_set_empty_cors1(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.empty_doc1)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc1)
-
-  def test_set_empty_cors2(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.empty_doc2)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc1)
-
-  def test_set_empty_cors3(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.empty_doc3)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc3)
-
-  def test_set_empty_cors4(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.empty_doc4)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc3)
-
-  def test_non_null_cors(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_doc)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)
-
-  def test_bad_cors1(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_bad1)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)], expected_status=1)
-
-  def test_bad_cors2(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_bad2)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)], expected_status=1)
-
-  def test_bad_cors3(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_bad3)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)], expected_status=1)
-
-  def test_bad_cors4(self):
-    bucket_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_bad4)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)], expected_status=1)
-
-  def set_cors_and_reset(self):
-    bucket_uri = self.CreateBucket()
-    tmpdir = self.CreateTempDir()
-    fpath = self.CreateTempFile(tmpdir=tmpdir, contents=self.cors_doc)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)
-
-    fpath = self.CreateTempFile(tmpdir=tmpdir, contents=self.empty_doc1)
-    self.RunGsUtil(['setcors', fpath, suri(bucket_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.empty_doc1)
-
-  def set_multi_non_null_cors(self):
-    bucket1_uri = self.CreateBucket()
-    bucket2_uri = self.CreateBucket()
-    fpath = self.CreateTempFile(contents=self.cors_doc)
-    self.RunGsUtil(['setcors', fpath, suri(bucket1_uri), suri(bucket2_uri)])
-    stdout = self.RunGsUtil(['getcors', suri(bucket1_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)
-    stdout = self.RunGsUtil(['getcors', suri(bucket2_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)
-
-  def test_set_wildcard_non_null_cors(self):
-    bucket1_uri = self.CreateBucket()
-    bucket2_uri = self.CreateBucket()
-    # This just double checks that the common prefix of the two buckets is what
-    # we think it should be (based on implementation detail of CreateBucket).
-    # We want to be careful when setting a wildcard on buckets to make sure we
-    # don't step outside the test buckets to effect other buckets.
-    common_prefix = posixpath.commonprefix([suri(bucket1_uri),
-                                            suri(bucket2_uri)])
-    self.assertEqual(common_prefix,
-                     'gs://gsutil-test-test_set_wildcard_non_null_cors-bucket-')
-    wildcard = '%s*' % common_prefix
-
-    fpath = self.CreateTempFile(contents=self.cors_doc)
-    stdout = self.RunGsUtil(['setcors', fpath, wildcard], return_stdout=True)
-    self.assertIn('Setting CORS on %s/...' % suri(bucket1_uri), stdout)
-    self.assertIn('Setting CORS on %s/...' % suri(bucket2_uri), stdout)
-    self.assertEqual(stdout.count('Setting CORS'), 2)
-
-    stdout = self.RunGsUtil(['getcors', suri(bucket1_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)
-    stdout = self.RunGsUtil(['getcors', suri(bucket2_uri)], return_stdout=True)
-    self.assertEqual(stdout, self.cors_doc)