gcloud 0.0.7 → 0.1.0

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

@@ -1,1904 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Unit tests for the instance commands."""
-
-from __future__ import with_statement
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import base64
-import copy
-import logging
-import sys
-import tempfile
-
-from google.apputils import app
-import gflags as flags
-import unittest
-
-from gcutil import command_base
-from gcutil import gcutil_logging
-from gcutil import instance_cmds
-from gcutil import mock_api
-
-
-FLAGS = flags.FLAGS
-LOGGER = gcutil_logging.LOGGER
-
-
-class InstanceCmdsTest(unittest.TestCase):
-
-  def setUp(self):
-    self._projects = mock_api.MockProjectsApi()
-    self._instances = mock_api.MockInstancesApi()
-    self._machine_types = mock_api.MockMachineTypesApi()
-    self._zones = mock_api.MockZonesApi()
-    self._disks = mock_api.MockDisksApi()
-    self._images = mock_api.MockImagesApi()
-
-    self._projects.get = mock_api.CommandExecutor(
-        {'externalIpAddresses': ['192.0.2.2', '192.0.2.3', '192.0.2.4']})
-
-    self._zones.list = mock_api.CommandExecutor(
-        {'kind': 'compute#zoneList',
-         'items': [{'name': 'zone1'},
-                   {'name': 'zone2'}]})
-
-    # This response is used for 'instances.list' on certain add calls.
-    self._instance_list = {
-        'items': [
-            {'name': 'foo',
-             'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                       'natIP': '192.0.2.2'}]}]
-            },
-            {'name': 'bar',
-             'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                       'natIP': '192.0.2.3'}]}]
-            },
-            ]}
-
-  def _DoTestAddInstanceGeneratesCorrectRequest(self, service_version):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_kernel = 'expected_kernel'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.machine_type = submitted_machine_type
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.kernel = submitted_kernel
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-    expected_kernel = command.NormalizeGlobalResourceName(expected_project,
-                                                          'kernels',
-                                                          submitted_kernel)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    expected_kind = command._GetResourceApiKind('instance')
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['kind'], expected_kind)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertEqual(result['body']['kernel'], expected_kernel)
-    self.assertFalse(
-        'natIP' in result['body']['networkInterfaces'][0]['accessConfigs'][0],
-        result)
-    self.assertEqual(exceptions, [])
-
-    self.assertEqual(result['body'].get('metadata'), {
-        'kind': 'compute#metadata',
-        'items': []})
-
-    instance_tags = result['body'].get('tags', [])
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-    self.assertEqual(instance_tags, [])
-
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-
-  def testAddInstanceGeneratesCorrectRequest(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._DoTestAddInstanceGeneratesCorrectRequest(version)
-
-  def _DoTestAddMultipleInstances(self, service_version):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instances = ['test-instance-%02d' % i for i in xrange(100)]
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.machine_type = submitted_machine_type
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(*expected_instances)
-
-    self.assertEqual(exceptions, [])
-    results = results['items']
-    self.assertEqual(len(results), len(expected_instances))
-
-    for (expected_instance, result) in zip(expected_instances, results):
-      expected_kind = command._GetResourceApiKind('instance')
-
-      self.assertEqual(result['project'], expected_project)
-      self.assertEqual(result['body']['kind'], expected_kind)
-      self.assertEqual(result['body']['name'], expected_instance)
-      self.assertEqual(result['body']['description'], expected_description)
-      self.assertEqual(result['body']['image'], expected_image)
-      self.assertFalse(
-          'natIP' in result['body']['networkInterfaces'][0]['accessConfigs'][0],
-          result)
-
-      self.assertEqual(result['body'].get('metadata'), {
-          'kind': 'compute#metadata',
-          'items': []})
-
-      instance_tags = result['body'].get('tags', [])
-      if command._IsUsingAtLeastApiVersion('v1beta14'):
-        instance_tags = result['body'].get('tags', {}).get('items', [])
-        self.assertFalse('zone' in result['body'])
-      else:
-        self.assertEqual(result['body']['zone'], expected_zone)
-      self.assertEqual(instance_tags, [])
-
-  def testAddMultipleInstances(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._DoTestAddMultipleInstances(version)
-
-
-  def testAddInstanceWithDiskOptionsGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = command_base.CURRENT_VERSION
-    expected_instance = 'test_instance'
-    submitted_image = 'image-foo'
-    submitted_zone = 'copernicus-moon-base'
-    submitted_disk_old_name = 'disk123:name123'
-    submitted_disk_name = 'disk234,deviceName=name234'
-    submitted_disk_read_only = 'disk345,mode=READ_ONLY'
-    submitted_disk_read_write = 'disk456,mode=READ_WRITE'
-    submitted_disk_name_read_only = 'disk567,deviceName=name567,mode=READ_ONLY'
-    submitted_disk_no_name = 'disk678'
-    submitted_disk_full_name = ('http://www.googleapis.com/compute/v1beta13/'
-                                'projects/google.com:test/disks/disk789')
-    submitted_disk_ro = 'disk890,mode=ro'
-    submitted_disk_rw = 'disk90A,mode=rw'
-    submitted_machine_type = 'goes_to_11'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-
-    flag_values.disk = [submitted_disk_old_name,
-                        submitted_disk_name,
-                        submitted_disk_read_only,
-                        submitted_disk_read_write,
-                        submitted_disk_name_read_only,
-                        submitted_disk_no_name,
-                        submitted_disk_full_name + ',mode=READ_WRITE',
-                        submitted_disk_ro,
-                        submitted_disk_rw]
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-    flag_values.image = submitted_image
-    flag_values.zone = submitted_zone
-
-    disk_zone = 'zones/copernicus-moon-base'
-
-    self._disks.get = mock_api.CommandExecutor(
-        {'zone': disk_zone})
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-    command._zones_api = self._zones
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._disks_api = self._disks
-    command._zones_api = self._zones
-    command._images_api = self._images
-    command._credential = mock_api.MockCredential()
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    disk = result['body']['disks'][0]
-    self.assertEqual(disk['deviceName'], 'name123')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    disk = result['body']['disks'][1]
-    self.assertEqual(disk['deviceName'], 'name234')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    disk = result['body']['disks'][2]
-    self.assertEqual(disk['deviceName'], 'disk345')
-    self.assertEqual(disk['mode'], 'READ_ONLY')
-    disk = result['body']['disks'][3]
-    self.assertEqual(disk['deviceName'], 'disk456')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    disk = result['body']['disks'][4]
-    self.assertEqual(disk['deviceName'], 'name567')
-    self.assertEqual(disk['mode'], 'READ_ONLY')
-    disk = result['body']['disks'][5]
-    self.assertEqual(disk['deviceName'], submitted_disk_no_name)
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    disk = result['body']['disks'][6]
-    self.assertEqual(disk['deviceName'], submitted_disk_full_name)
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    disk = result['body']['disks'][7]
-    self.assertEqual(disk['deviceName'], 'disk890')
-    self.assertEqual(disk['mode'], 'READ_ONLY')
-    disk = result['body']['disks'][8]
-    self.assertEqual(disk['deviceName'], 'disk90A')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceWithBootDiskOptionsGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = 'v1beta14'
-    expected_instance = 'test_instance'
-    submitted_boot_disk_unqualified = 'diskA,boot'
-    submitted_boot_disk_ro = 'diskB,mode=ro,boot'
-    submitted_boot_disk_rw = 'diskC,mode=rw,boot'
-    submitted_non_boot_disk = 'diskD'
-    submitted_machine_type = 'goes_to_11'
-    submitted_kernel = 'projects/google/kernels/some-kernel'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-
-    flag_values.disk = [submitted_boot_disk_unqualified,
-                        submitted_boot_disk_ro,
-                        submitted_boot_disk_rw,
-                        submitted_non_boot_disk]
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-    flag_values.kernel = submitted_kernel
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    # When no zone is provided, GCUtil will do a list
-    disk_zone = 'zone1'
-    disk_list_with_zone = {
-        'items': [
-            {'selfLink': 'projects/foo/zones/%s/disks/baz' % disk_zone},
-            ]}
-    self._disks.list = mock_api.CommandExecutor(disk_list_with_zone)
-
-    # Override to return a single zone so that we don't find multiple
-    # disks with the same name
-    self._zones.list = mock_api.CommandExecutor(
-        {'kind': 'compute#zoneList',
-         'items': [{'name': 'zone1'}]})
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._disks_api = self._disks
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    disk = result['body']['disks'][0]
-    self.assertEqual(disk['deviceName'], 'diskA')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    self.assertEqual(disk['boot'], True)
-
-    disk = result['body']['disks'][1]
-    self.assertEqual(disk['deviceName'], 'diskB')
-    self.assertEqual(disk['mode'], 'READ_ONLY')
-    self.assertEqual(disk['boot'], True)
-
-    disk = result['body']['disks'][2]
-    self.assertEqual(disk['deviceName'], 'diskC')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    self.assertEqual(disk['boot'], True)
-
-    disk = result['body']['disks'][3]
-    self.assertEqual(disk['deviceName'], 'diskD')
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    self.assertEqual(disk['boot'], False)
-    self.assertEqual(exceptions, [])
-
-    # Make sure we got the zone for the right disk.
-    self.assertEqual(2, self._disks.list._parameters['maxResults'])
-    self.assertEqual('name eq diskA', self._disks.list._parameters['filter'])
-
-    expected_kernel = command.NormalizeGlobalResourceName('google',
-                                                          'kernels',
-                                                          submitted_kernel)
-    self.assertEqual(expected_kernel, result['body']['kernel'])
-    self.assertEqual(disk_zone, result['zone'])
-
-  def testPersistentBootDisk(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = 'v1beta14'
-    expected_instance = 'test_instance'
-    submitted_machine_type = 'machine-type1'
-    submitted_zone = 'zone1'
-    submitted_image = 'projects/google/global/images/some-image'
-    submitted_project = 'test_project_name'
-    image_kernel = 'projects/google/global/kernels/image-kernel'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.project = submitted_project
-    flag_values.machine_type = submitted_machine_type
-    flag_values.zone = submitted_zone
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-    flag_values.image = submitted_image
-    flag_values.persistent_boot_disk = True
-
-    self._images.get = mock_api.CommandExecutor(
-        {'preferredKernel': image_kernel})
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._disks_api = self._disks
-    command._images_api = self._images
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    # Make sure boot PD was created from image.
-    self.assertEqual(1, len(command._disks_api.requests))
-
-    disk_insert = command._disks_api.requests[0].request_payload
-    expected_disk_name = 'boot-%s' % (expected_instance)
-    expected_image = command.NormalizeGlobalResourceName('google',
-                                                         'images',
-                                                         submitted_image)
-    expected_zone = command.NormalizeTopLevelResourceName(submitted_project,
-                                                          'zones',
-                                                          submitted_zone)
-    self.assertEqual(expected_disk_name, disk_insert['body']['name'])
-    self.assertEqual(expected_image, disk_insert['sourceImage'])
-    self.assertEqual('google', self._images.get._parameters['project'])
-    self.assertEqual('some-image', self._images.get._parameters['image'])
-
-    # Make sure the disk was attached to the instance.
-    disk = result['body']['disks'][0]
-    self.assertEqual(disk['deviceName'], 'boot-' + expected_instance)
-    self.assertEqual(disk['mode'], 'READ_WRITE')
-    self.assertEqual(disk['boot'], True)
-    self.assertEqual(exceptions, [])
-
-    # Make sure the kernel was set from the image.
-    expected_kernel = command.NormalizeGlobalResourceName('google',
-                                                          'kernels',
-                                                          image_kernel)
-    self.assertEqual(expected_kernel, result['body']['kernel'])
-
-    # Make sure image was not set.
-    self.assertFalse('image' in result['body'])
-
-  def testAddInstanceWithDiskGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-    service_version = command_base.CURRENT_VERSION
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_disk = 'disk123'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.disk = [submitted_disk]
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._disks_api = self._disks
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    zone_path = 'projects/test_project/zones/%s' % submitted_zone
-    self._disks.get = mock_api.CommandExecutor(
-        {'zone': zone_path})
-    self._zones.list = mock_api.CommandExecutor(
-        {'kind': 'compute#zoneList',
-         'items': [{'name': submitted_zone}]})
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_disk = command.NormalizePerZoneResourceName(expected_project,
-                                                         submitted_zone,
-                                                         'disks',
-                                                         submitted_disk)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertEqual(result['body']['disks'][0]['source'], expected_disk)
-    self.assertFalse(
-        'natIP' in result['body']['networkInterfaces'][0]['accessConfigs'][0],
-        result)
-    self.assertEqual(result['body'].get('metadata', {}), expected_metadata)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceGeneratesEphemeralIpRequestForProjectWithNoIps(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._projects.get = mock_api.CommandExecutor(
-        {'externalIpAddresses': []})
-    self._instances.list = mock_api.CommandExecutor({'items': []})
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertFalse('natIP' in
-                     result['body']['networkInterfaces'][0]['accessConfigs'][0],
-                     result)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceNoExistingVmsRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._projects.get = mock_api.CommandExecutor(
-        {'externalIpAddresses': ['192.0.2.2', '192.0.2.3']})
-    self._instances.list = mock_api.CommandExecutor(
-        {'kind': 'cloud#instances'})
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertFalse(
-        'natIP' in result['body']['networkInterfaces'][0]['accessConfigs'][0],
-        result)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceWithSpecifiedInternalAddress(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    expected_internal_ip = '10.0.0.1'
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.internal_ip_address = expected_internal_ip
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertEqual(result['body']['networkInterfaces'][0]['networkIP'],
-                     expected_internal_ip)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceGeneratesNewIpRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.external_ip_address = 'ephemeral'
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertFalse('natIP' in
-                     result['body']['networkInterfaces'][0]['accessConfigs'][0])
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceGeneratesNoExternalIpRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.external_ip_address = 'None'
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertFalse('accessConfigs' in result['body']['networkInterfaces'][0])
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-    self.assertEqual(instance_tags, [])
-    self.assertEqual(exceptions, [])
-
-  def testAddInstanceRequiresZone(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = command_base.CURRENT_VERSION
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'us-east-a'
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    flag_values.add_compute_key_to_project = False
-
-    command.SetFlags(flag_values)
-    command._credential = mock_api.MockCredential()
-
-    mock_output = mock_api.MockOutput()
-    mock_input = mock_api.MockInput('1\n\r')
-
-    oldin = sys.stdin
-    sys.stdin = mock_input
-    oldout = sys.stdout
-    sys.stdout = mock_output
-
-    def GetZonePath(part_one, part_two, part_three):
-      return 'projects/test_project/zones/%s-%s-%s' % (part_one,
-                                                       part_two,
-                                                       part_three)
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-    self._zones.list = mock_api.CommandExecutor(
-        {'items': [
-            {'name': GetZonePath('us', 'east', 'a')},
-            {'name': GetZonePath('us', 'east', 'b')},
-            {'name': GetZonePath('us', 'east', 'c')},
-            {'name': GetZonePath('us', 'west', 'a')}]})
-
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(exceptions, [])
-    sys.stdin = oldin
-    sys.stdout = oldout
-
-  def _DoTestAddInstanceWithServiceAccounts(self,
-                                            expected_service_account,
-                                            expected_scopes,
-                                            should_succeed):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    service_version = 'v1beta13'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-    expected_authorized_ssh_keys = []
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.external_ip_address = 'None'
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = expected_authorized_ssh_keys
-    if expected_service_account:
-      # addinstance command checks whether --service_account is explicitly
-      # given, so in this case, set the present flag along with the value.
-      flag_values['service_account'].present = True
-      flag_values.service_account = expected_service_account
-    else:
-      # The default 'default' will be expected after command.Handle.
-      expected_service_account = 'default'
-    if expected_scopes:
-      flag_values.service_account_scopes = expected_scopes
-    else:
-      # The default [] will be expected after command.Handle.
-      expected_scopes = []
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    if not should_succeed:
-      self.assertRaises(app.UsageError,
-                        command.Handle,
-                        expected_instance)
-    else:
-      (results, exceptions) = command.Handle(expected_instance)
-      result = results['items'][0]
-
-      self.assertEqual(result['project'], expected_project)
-      self.assertEqual(result['body']['name'], expected_instance)
-      self.assertEqual(result['body']['description'], expected_description)
-      self.assertEqual(result['body']['image'], expected_image)
-      self.assertFalse('accessConfigs' in
-                       result['body']['networkInterfaces'][0])
-      self.assertEqual(result['body'].get('metadata'), expected_metadata)
-      if command._IsUsingAtLeastApiVersion('v1beta14'):
-        instance_tags = result['body'].get('tags', {}).get('items', [])
-        self.assertEqual(submitted_zone, result['zone'])
-        self.assertFalse('zone' in result['body'])
-      else:
-        instance_tags = result['body'].get('tags', [])
-        self.assertFalse('zone' in result)
-        self.assertEqual(result['body']['zone'], expected_zone)
-      self.assertEqual(instance_tags, [])
-      self.assertEqual(result['body']['serviceAccounts'][0]['email'],
-                       expected_service_account)
-      self.assertEqual(result['body']['serviceAccounts'][0]['scopes'],
-                       sorted(expected_scopes))
-      self.assertEqual(exceptions, [])
-
-  def testAddInstanceWithServiceAccounts(self):
-    email = 'random.default@developer.googleusercontent.com'
-    scope1 = 'https://www.googleapis.com/auth/fake.product1'
-    scope2 = 'https://www.googleapis.com/auth/fake.product2'
-    self._DoTestAddInstanceWithServiceAccounts(None, [scope1], True)
-    self._DoTestAddInstanceWithServiceAccounts(email, [scope1], True)
-    self._DoTestAddInstanceWithServiceAccounts(email, [scope1, scope2], True)
-    self._DoTestAddInstanceWithServiceAccounts(email, None, False)
-
-  def testAddInstanceWithUnknownKeyFile(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-    expected_instance = 'test_instance'
-    flag_values.project = 'test_project'
-    flag_values.zone = submitted_zone
-    flag_values.description = 'test instance'
-    flag_values.image = 'expected_image'
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = ['user:unknown-file']
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    self.assertRaises(IOError,
-                      command.Handle,
-                      expected_instance)
-
-  def testAddAuthorizedUserKeyToProject(self):
-    flag_values = copy.deepcopy(FLAGS)
-    flag_values.service_version = 'v1beta13'
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    class SetCommonInstanceMetadata(object):
-      def __init__(self, record):
-        self.record = record
-
-      def __call__(self, project, body):
-        self.record['project'] = project
-        self.record['body'] = body
-        return self
-
-      def execute(self):
-        pass
-
-    ssh_keys = ''
-    self._projects.get = mock_api.CommandExecutor(
-        {'commonInstanceMetadata': {
-            'kind': 'compute#metadata',
-            'items': [{'key': 'sshKeys', 'value': ssh_keys}]}})
-    call_record = {}
-    self._projects.setCommonInstanceMetadata = SetCommonInstanceMetadata(
-        call_record)
-    expected_project = 'test_project'
-
-    flag_values.service_version = 'v1beta13'
-    flag_values.project = expected_project
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._credential = mock_api.MockCredential()
-
-    result = command._AddAuthorizedUserKeyToProject(
-        {'user': 'foo', 'key': 'bar'})
-    self.assertTrue(result)
-    self.assertEquals(expected_project, call_record['project'])
-    self.assertEquals(
-        {'kind': 'compute#metadata',
-         'items': [{'key': 'sshKeys', 'value': 'foo:bar'}]},
-        call_record['body'])
-
-  def testAddAuthorizedUserKeyAlreadyInProject(self):
-    flag_values = copy.deepcopy(FLAGS)
-    flag_values.service_version = 'v1beta13'
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    class SetCommonInstanceMetadata(object):
-      def __init__(self, record):
-        self.record = record
-
-      def __call__(self, project, body):
-        self.record['project'] = project
-        self.record['body'] = body
-        return self
-
-      def execute(self):
-        pass
-
-    ssh_keys = 'baz:bat\nfoo:bar\ni:j'
-    self._projects.get = mock_api.CommandExecutor(
-        {'commonInstanceMetadata': {
-            'kind': 'compute#metadata',
-            'items': [{'key': 'sshKeys', 'value': ssh_keys}]}})
-    call_record = {}
-    self._projects.setCommonInstanceMetadata = SetCommonInstanceMetadata(
-        call_record)
-    expected_project = 'test_project'
-
-    flag_values.service_version = 'v1beta13'
-    flag_values.project = expected_project
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._credential = mock_api.MockCredential()
-
-    result = command._AddAuthorizedUserKeyToProject(
-        {'user': 'foo', 'key': 'bar'})
-    self.assertFalse(result)
-
-  def _testAddSshKeysToMetadataHelper(self,
-                                      test_ssh_key_through_file,
-                                      test_ssh_key_through_flags):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-    flag_values.use_compute_key = False
-    ssh_rsa_key = ('ssh-rsa ' +
-                   base64.b64encode('\00\00\00\07ssh-rsa the ssh key') +
-                   ' comment')
-
-    with tempfile.NamedTemporaryFile() as metadata_file:
-      with tempfile.NamedTemporaryFile() as ssh_key_file:
-        metadata_file.write('metadata file content')
-        metadata_file.flush()
-        flag_values.metadata_from_file = ['bar_file:%s' % metadata_file.name]
-
-        flag_values.metadata = ['bar:baz']
-
-        if test_ssh_key_through_file:
-          ssh_key_file.write(ssh_rsa_key)
-          ssh_key_file.flush()
-          flag_values.authorized_ssh_keys = ['user:%s' % ssh_key_file.name]
-
-        if test_ssh_key_through_flags:
-          flag_values.metadata.append('sshKeys:user2:flags ssh key')
-
-        command.SetFlags(flag_values)
-        metadata_flags_processor = command._metadata_flags_processor
-        extended_metadata = command._AddSshKeysToMetadata(
-            metadata_flags_processor.GatherMetadata())
-
-    self.assertTrue(len(extended_metadata) >= 2)
-    self.assertEqual(extended_metadata[0]['key'], 'bar')
-    self.assertEqual(extended_metadata[0]['value'], 'baz')
-    self.assertEqual(extended_metadata[1]['key'], 'bar_file')
-    self.assertEqual(extended_metadata[1]['value'], 'metadata file content')
-
-    ssh_keys = []
-    if test_ssh_key_through_flags:
-      ssh_keys.append('user2:flags ssh key')
-    if test_ssh_key_through_file:
-      ssh_keys.append('user:' + ssh_rsa_key)
-
-    if test_ssh_key_through_flags or test_ssh_key_through_file:
-      self.assertEqual(len(extended_metadata), 3)
-      self.assertEqual(extended_metadata[2]['key'], 'sshKeys')
-      self.assertEqual(extended_metadata[2]['value'],
-                       '\n'.join(ssh_keys))
-
-  def testGatherMetadata(self):
-    self._testAddSshKeysToMetadataHelper(False, False)
-    self._testAddSshKeysToMetadataHelper(False, True)
-    self._testAddSshKeysToMetadataHelper(True, False)
-    self._testAddSshKeysToMetadataHelper(True, True)
-
-  def testBuildInstanceRequestWithMetadataAndDisk(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_zone = 'copernicus-moon-base'
-    flag_values.service_version = 'v1beta13'
-    flag_values.project = expected_project
-    flag_values.zone = submitted_zone
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = []
-    flag_values.add_compute_key_to_project = False
-    metadata = [{'key': 'foo', 'value': 'bar'}]
-    disks = [{'source': ('http://www.googleapis.com/compute/v1beta13/projects/'
-                         'google.com:test/disks/disk789'),
-              'deviceName': 'disk789', 'mode': 'READ_WRITE',
-              'type': 'PERSISTENT', 'boot': False}]
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': metadata}
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-
-    result = command._BuildRequestWithMetadata(
-        expected_instance, metadata, disks).execute()
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertEqual(result['body']['metadata'], expected_metadata)
-    self.assertEqual(result['body']['disks'], disks)
-
-  def testBuildInstanceRequestWithTag(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddInstance('addinstance', flag_values)
-
-    service_version = 'v1beta13'
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_description = 'test instance'
-    submitted_image = 'expected_image'
-    submitted_machine_type = 'goes_to_11'
-    submitted_zone = 'copernicus-moon-base'
-    expected_tags = ['tag0', 'tag1', 'tag2']
-
-    flag_values.service_version = service_version
-    flag_values.project = expected_project
-    flag_values.zone = submitted_zone
-    flag_values.description = expected_description
-    flag_values.image = submitted_image
-    flag_values.machine_type = submitted_machine_type
-    flag_values.use_compute_key = False
-    flag_values.authorized_ssh_keys = []
-    flag_values.tags = expected_tags * 2  # Create duplicates.
-    flag_values.add_compute_key_to_project = False
-
-    self._instances.list = mock_api.CommandExecutor(self._instance_list)
-
-    command.SetFlags(flag_values)
-    command._projects_api = self._projects
-    command._instances_api = self._instances
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    expected_metadata = {'kind': 'compute#metadata',
-                         'items': []}
-
-    expected_image = command.NormalizeGlobalResourceName(expected_project,
-                                                         'images',
-                                                         submitted_image)
-
-    expected_zone = command.NormalizeTopLevelResourceName(
-        expected_project,
-        'zones',
-        submitted_zone)
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_instance)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['image'], expected_image)
-    self.assertFalse(
-        'natIP' in result['body']['networkInterfaces'][0]['accessConfigs'][0],
-        result)
-    self.assertEqual(result['body'].get('metadata'), expected_metadata)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = result['body'].get('tags', {}).get('items', [])
-      self.assertEqual(submitted_zone, result['zone'])
-      self.assertFalse('zone' in result['body'])
-    else:
-      instance_tags = result['body'].get('tags', [])
-      self.assertFalse('zone' in result)
-      self.assertEqual(result['body']['zone'], expected_zone)
-    self.assertEqual(instance_tags, expected_tags)
-    self.assertEqual(exceptions, [])
-
-  def testGetInstanceGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.GetInstance('getinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    flag_values.project = expected_project
-    flag_values.zone = 'zone-a'
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._credential = mock_api.MockCredential()
-
-    result = command.Handle(expected_instance)
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['instance'], expected_instance)
-
-  def _DoTestDeleteInstanceGeneratesCorrectRequest(self, service_version):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.DeleteInstance('deleteinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    submitted_zone = 'copernicus-moon-base'
-    flag_values.project = expected_project
-    flag_values.service_version = service_version
-    flag_values.zone = submitted_zone
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._credential = mock_api.MockCredential()
-
-    (results, exceptions) = command.Handle(expected_instance)
-    result = results['items'][0]
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['instance'], expected_instance)
-    self.assertEqual(exceptions, [])
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      self.assertEqual(submitted_zone, result['zone'])
-    else:
-      self.assertFalse('zone' in result)
-
-  def testDeleteInstanceGeneratesCorrectRequest(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._DoTestDeleteInstanceGeneratesCorrectRequest(version)
-
-  def testDeleteMultipleInstances(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.DeleteInstance('deleteinstance', flag_values)
-
-    expected_project = 'test_project'
-    expected_instances = ['test-instance-%02d' % i for i in range(100)]
-    flag_values.project = expected_project
-    flag_values.zone = 'zone-a'
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-
-    (results, exceptions) = command.Handle(*expected_instances)
-    self.assertEqual(exceptions, [])
-    results = results['items']
-    self.assertEqual(len(results), len(expected_instances))
-
-    for (expected_instance, result) in zip(expected_instances, results):
-      self.assertEqual(result['project'], expected_project)
-      self.assertEqual(result['instance'], expected_instance)
-
-  def _DoTestAddAccessConfigGeneratesCorrectRequest(self, service_version):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.AddAccessConfig('addaccessconfig', flag_values)
-
-    expected_project_name = 'test_project_name'
-    expected_instance_name = 'test_instance_name'
-    expected_network_interface_name = 'test_network_interface_name'
-    expected_access_config_name = 'test_access_config_name'
-    expected_access_config_type = 'test_access_config_type'
-    expected_access_config_nat_ip = 'test_access_config_nat_ip'
-
-    flag_values.project = expected_project_name
-    flag_values.network_interface_name = expected_network_interface_name
-    flag_values.access_config_name = expected_access_config_name
-    flag_values.access_config_type = expected_access_config_type
-    flag_values.access_config_nat_ip = expected_access_config_nat_ip
-    flag_values.service_version = service_version
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._credential = mock_api.MockCredential()
-    submitted_zone = 'copernicus-moon-base'
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      flag_values.zone = submitted_zone
-
-    result = command.Handle(expected_instance_name)
-
-    self.assertEqual(result['project'], expected_project_name)
-    self.assertEqual(result['instance'], expected_instance_name)
-    self.assertEqual(result['network_interface'],
-                     expected_network_interface_name)
-    self.assertEqual(result['body']['name'], expected_access_config_name)
-    self.assertEqual(result['body']['type'], expected_access_config_type)
-    self.assertEqual(result['body']['natIP'], expected_access_config_nat_ip)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      self.assertEqual(submitted_zone, result['zone'])
-    else:
-      self.assertFalse('zone' in result)
-
-  def testAddAccessConfigGeneratesCorrectRequest(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._DoTestAddAccessConfigGeneratesCorrectRequest(version)
-
-  def _DoTestDeleteAccessConfigGeneratesCorrectRequest(self, service_version):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.DeleteAccessConfig('deleteaccessconfig',
-                                               flag_values)
-
-    expected_project_name = 'test_project_name'
-    expected_instance_name = 'test_instance_name'
-    expected_network_interface_name = 'test_network_interface_name'
-    expected_access_config_name = 'test_access_config_name'
-
-    flag_values.project = expected_project_name
-    flag_values.network_interface_name = expected_network_interface_name
-    flag_values.access_config_name = expected_access_config_name
-    flag_values.service_version = service_version
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._zones_api = self._zones
-    command._credential = mock_api.MockCredential()
-    submitted_zone = 'copernicus-moon-base'
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      flag_values.zone = submitted_zone
-
-    result = command.Handle(expected_instance_name)
-
-    self.assertEqual(result['project'], expected_project_name)
-    self.assertEqual(result['instance'], expected_instance_name)
-    self.assertEqual(result['network_interface'],
-                     expected_network_interface_name)
-    self.assertEqual(result['access_config'],
-                     expected_access_config_name)
-    if command._IsUsingAtLeastApiVersion('v1beta14'):
-      self.assertEqual(submitted_zone, result['zone'])
-    else:
-      self.assertFalse('zone' in result)
-
-  def testDeleteAccessConfigGeneratesCorrectRequest(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._DoTestDeleteAccessConfigGeneratesCorrectRequest(version)
-
-  def testSetInstanceMetadataGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SetMetadata('setinstancemetadata', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_fingerprint = 'asdfg'
-    submitted_zone = 'zone-a'
-    flag_values.project = expected_project
-    flag_values.fingerprint = expected_fingerprint
-    flag_values.zone = submitted_zone
-
-    with tempfile.NamedTemporaryFile() as metadata_file:
-      metadata_file.write('foo:bar')
-      metadata_file.flush()
-      flag_values.metadata_from_file = ['sshKeys:%s' % metadata_file.name]
-
-      command.SetFlags(flag_values)
-      command.SetApi(mock_api.MockApi())
-      command._instances_api.get = mock_api.CommandExecutor(
-          {'metadata': {'kind': 'compute#metadata',
-                        'items': [{'key': 'sshKeys', 'value': ''}]}})
-      command._projects_api.get = mock_api.CommandExecutor(
-          {'commonInstanceMetadata': {'kind': 'compute#metadata',
-                                      'items': [{'key': 'sshKeys',
-                                                 'value': ''}]}})
-      command._zones_api = self._zones
-
-      result = command.Handle(expected_instance)
-      self.assertEquals(expected_project, result['project'])
-      self.assertEquals(expected_instance, result['instance'])
-      self.assertEquals(
-          {'kind': 'compute#metadata',
-           'fingerprint': expected_fingerprint,
-           'items': [{'key': 'sshKeys', 'value': 'foo:bar'}]},
-          result['body'])
-
-  def testSetMetadataChecksSshKeys(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SetMetadata(
-        'setinstancemetadata', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_fingerprint = 'asdfg'
-    flag_values.project = expected_project
-    flag_values.fingerprint = expected_fingerprint
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._instances_api.get = mock_api.CommandExecutor(
-        {'metadata': {'kind': 'compute#metadata',
-                      'items': [{'key': 'sshKeys', 'value': 'xyz'}]}})
-    command._projects_api.get = mock_api.CommandExecutor(
-        {'commonInstanceMetadata': {'kind': 'compute#metadata',
-                                    'items': [{'key': 'noSshKey',
-                                               'value': 'none'}]}})
-    command._zones_api = self._zones
-
-    self.assertRaises(command_base.CommandError,
-                      command.Handle, expected_instance)
-
-  def testSetMetadataFailsWithNofingerprint(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SetMetadata('setinstancemetadata', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    submitted_zone = 'zone-a'
-    flag_values.project = expected_project
-    flag_values.zone = submitted_zone
-
-    with tempfile.NamedTemporaryFile() as metadata_file:
-      metadata_file.write('foo:bar')
-      metadata_file.flush()
-      flag_values.metadata_from_file = ['sshKeys:%s' % metadata_file.name]
-
-      command.SetFlags(flag_values)
-      command.SetApi(mock_api.MockApi())
-      command._instances_api.get = mock_api.CommandExecutor(
-          {'metadata': {'kind': 'compute#metadata',
-                        'items': [{'key': 'sshKeys', 'value': ''}]}})
-      command._projects_api.get = mock_api.CommandExecutor(
-          {'commonInstanceMetadata': {'kind': 'compute#metadata',
-                                      'items': [{'key': 'sshKeys',
-                                                 'value': ''}]}})
-      command._zones_api = self._zones
-      self.assertRaises(app.UsageError, command.Handle, expected_instance)
-
-  def testSetTagsGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SetTags('settags', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_fingerprint = 'test-hash'
-    expected_tags = ['tag0', 'tag1', 'tag2']
-    submitted_zone = 'zone-a'
-    flag_values.project = expected_project
-    flag_values.fingerprint = expected_fingerprint
-    flag_values.tags = expected_tags
-    flag_values.zone = submitted_zone
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._zones_api = self._zones
-
-    result = command.Handle(expected_instance)
-
-    self.assertEqual(result['instance'], expected_instance)
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body'].get('fingerprint'), expected_fingerprint)
-    self.assertEqual(result['body'].get('items'), expected_tags)
-
-  def testSetTagsFailsWithNoFingerprint(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SetTags('settags', flag_values)
-
-    expected_project = 'test_project'
-    expected_instance = 'test_instance'
-    expected_tags = ['tag0', 'tag1', 'tag2']
-    submitted_zone = 'zone-a'
-    flag_values.project = expected_project
-    flag_values.tags = expected_tags
-    flag_values.zone = submitted_zone
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._zones_api = self._zones
-
-    self.assertRaises(app.UsageError, command.Handle, expected_instance)
-
-  def testGetSshAddressChecksForNetworkInterfaces(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'someFieldOtherThanNetworkInterfaces': [],
-                     'status': 'RUNNING'}
-
-    self.assertRaises(command_base.CommandError,
-                      command._GetSshAddress,
-                      mock_instance)
-
-  def testGetSshAddressChecksForNonEmptyNetworkInterfaces(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [], 'status': 'RUNNING'}
-
-    self.assertRaises(command_base.CommandError,
-                      command._GetSshAddress,
-                      mock_instance)
-
-  def testGetSshAddressChecksForAccessConfigs(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [{}]}
-
-    self.assertRaises(command_base.CommandError,
-                      command._GetSshAddress,
-                      mock_instance)
-
-  def testGetSshAddressChecksForNonEmptyAccessConfigs(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [{'accessConfigs': []}],
-                     'status': 'RUNNING'}
-
-    self.assertRaises(command_base.CommandError,
-                      command._GetSshAddress,
-                      mock_instance)
-
-  def testGetSshAddressChecksForNatIp(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [{'accessConfigs': [{}]}],
-                     'status': 'RUNNING'}
-
-    self.assertRaises(command_base.CommandError,
-                      command._GetSshAddress,
-                      mock_instance)
-
-  def testEnsureSshableChecksForSshKeysInTheInstance(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [{'accessConfigs': [{}]}],
-                     'status': 'RUNNING',
-                     'metadata': {u'kind': u'compute#metadata',
-                                  u'items': [{u'key': u'sshKeys',
-                                              u'value': ''}]}}
-
-    def MockAddComputeKeyToProject():
-      self.fail('Unexpected call to _AddComputeKeyToProject')
-
-    command._AddComputeKeyToProject = MockAddComputeKeyToProject
-    command._EnsureSshable(mock_instance)
-
-  def testEnsureSshableChecksForNonRunningInstance(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshInstanceBase('test', flag_values)
-    command.SetFlags(flag_values)
-    mock_instance = {'networkInterfaces': [{'accessConfigs': [{}]}],
-                     'status': 'STAGING'}
-
-    self.assertRaises(command_base.CommandError,
-                      command._EnsureSshable,
-                      mock_instance)
-
-  def testSshGeneratesCorrectArguments(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshToInstance('ssh', flag_values)
-
-    argv = ['arg1', '%arg2', 'arg3']
-    expected_arg_list = ['-A', '-p', '%(port)d', '%(user)s@%(host)s',
-                         '--', 'arg1', '%%arg2', 'arg3']
-
-    arg_list = command._GenerateSshArgs(*argv)
-
-    self.assertEqual(expected_arg_list, arg_list)
-
-  def testSshPassesThroughSshArg(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshToInstance('ssh', flag_values)
-    ssh_arg = '--passedSshArgKey=passedSshArgValue'
-    flag_values.ssh_arg = [ssh_arg]
-    command.SetFlags(flag_values)
-    ssh_args = command._GenerateSshArgs(*[])
-    mock_instance_resource = {
-        'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                  'natIP': '0.0.0.0'}]}],
-        'status': 'RUNNING'}
-    command_line = command._BuildSshCmd(mock_instance_resource, 'ssh', ssh_args)
-    self.assertTrue(ssh_arg in command_line)
-
-  def testSshPassesThroughTwoSshArgs(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshToInstance('ssh', flag_values)
-    ssh_arg1 = '--k1=v1'
-    ssh_arg2 = '--k2=v2'
-    flag_values.ssh_arg = [ssh_arg1, ssh_arg2]
-    command.SetFlags(flag_values)
-    ssh_args = command._GenerateSshArgs(*[])
-    mock_instance_resource = {
-        'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                  'natIP': '0.0.0.0'}]}],
-        'status': 'RUNNING'}
-    command_line = command._BuildSshCmd(mock_instance_resource, 'ssh', ssh_args)
-
-    self.assertTrue(ssh_arg1 in command_line)
-    self.assertTrue(ssh_arg2 in command_line)
-
-  def testSshGeneratesCorrectCommand(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.SshToInstance('ssh', flag_values)
-
-    expected_project = 'test_project'
-    expected_ip = '1.1.1.1'
-    expected_port = 22
-    expected_user = 'test_user'
-    expected_ssh_file = 'test_file'
-    flag_values.project = expected_project
-    flag_values.ssh_port = expected_port
-    flag_values.ssh_user = expected_user
-    flag_values.private_key_file = expected_ssh_file
-
-    ssh_args = ['-A', '-p', '%(port)d', '%(user)s@%(host)s', '--']
-
-    expected_command = [
-        'ssh', '-o', 'UserKnownHostsFile=/dev/null',
-        '-o', 'CheckHostIP=no',
-        '-o', 'StrictHostKeyChecking=no',
-        '-i', expected_ssh_file,
-        '-A', '-p', str(expected_port),
-        '%s@%s' % (expected_user, expected_ip),
-        '--']
-
-    if LOGGER.level <= logging.DEBUG:
-      expected_command.insert(-5, '-v')
-
-    command.SetFlags(flag_values)
-    mock_instance_resource = {
-        'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                  'natIP': expected_ip}]}],
-        'status': 'RUNNING'}
-    command_line = command._BuildSshCmd(mock_instance_resource, 'ssh', ssh_args)
-
-    self.assertEqual(expected_command, command_line)
-
-  def testScpPushGeneratesCorrectArguments(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.PushToInstance('push', flag_values)
-
-    argv = ['file1', '%file2', 'destination']
-    expected_arg_list = ['-r', '-P', '%(port)d', '--',
-                         'file1',
-                         '%%file2',
-                         '%(user)s@%(host)s:destination']
-
-    arg_list = command._GenerateScpArgs(*argv)
-
-    self.assertEqual(expected_arg_list, arg_list)
-
-  def testScpPushGeneratesCorrectCommand(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.PushToInstance('push', flag_values)
-
-    expected_project = 'test_project'
-    expected_ip = '1.1.1.1'
-    expected_port = 22
-    expected_user = 'test_user'
-    expected_ssh_file = 'test_file'
-    expected_local_file = 'test_source'
-    expected_remote_file = 'test_remote'
-    flag_values.project = expected_project
-    flag_values.ssh_port = expected_port
-    flag_values.ssh_user = expected_user
-    flag_values.private_key_file = expected_ssh_file
-
-    scp_args = ['-P', '%(port)d', '--']
-    unused_argv = ('', expected_local_file, expected_remote_file)
-
-    escaped_args = [a.replace('%', '%%') for a in unused_argv]
-    scp_args.extend(escaped_args[1:-1])
-    scp_args.append('%(user)s@%(host)s:' + escaped_args[-1])
-
-    expected_command = [
-        'scp',
-        '-o', 'UserKnownHostsFile=/dev/null',
-        '-o', 'CheckHostIP=no',
-        '-o', 'StrictHostKeyChecking=no',
-        '-i', expected_ssh_file,
-        '-P', str(expected_port),
-        '--', expected_local_file,
-        '%s@%s:%s' % (expected_user, expected_ip, expected_remote_file)]
-
-    if LOGGER.level <= logging.DEBUG:
-      expected_command.insert(-5, '-v')
-
-    command.SetFlags(flag_values)
-    mock_instance_resource = {
-        'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                  'natIP': expected_ip}]}],
-        'status': 'RUNNING'}
-
-    command_line = command._BuildSshCmd(mock_instance_resource, 'scp', scp_args)
-
-    self.assertEqual(expected_command, command_line)
-
-  def testScpPullGeneratesCorrectArguments(self):
-    class MockGetApi(object):
-      def __init__(self, nat_ip='0.0.0.0'):
-        self._nat_ip = nat_ip
-
-      def instances(self):
-        return self
-
-      def get(self, *unused_args, **unused_kwargs):
-        return self
-
-      def execute(self):
-        return {'status': 'RUNNING'}
-
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.PullFromInstance('pull', flag_values)
-
-    command._instances_api = MockGetApi()
-
-    argv = ['file1', '%file2', 'destination']
-    expected_arg_list = ['-r', '-P', '%(port)d', '--',
-                         '%(user)s@%(host)s:file1',
-                         '%(user)s@%(host)s:%%file2',
-                         'destination']
-
-    arg_list = command._GenerateScpArgs(*argv)
-
-    self.assertEqual(expected_arg_list, arg_list)
-
-  def testScpPullGeneratesCorrectCommand(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = instance_cmds.PushToInstance('push', flag_values)
-
-    expected_project = 'test_project'
-    expected_ip = '1.1.1.1'
-    expected_port = 22
-    expected_user = 'test_user'
-    expected_ssh_file = 'test_file'
-    expected_local_file = 'test_source'
-    expected_remote_file = 'test_remote'
-    flag_values.project = expected_project
-    flag_values.ssh_port = expected_port
-    flag_values.ssh_user = expected_user
-    flag_values.private_key_file = expected_ssh_file
-
-    scp_args = ['-P', '%(port)d', '--']
-    unused_argv = ('', expected_remote_file, expected_local_file)
-
-    escaped_args = [a.replace('%', '%%') for a in unused_argv]
-    for arg in escaped_args[1:-1]:
-      scp_args.append('%(user)s@%(host)s:' + arg)
-    scp_args.append(escaped_args[-1])
-
-    expected_command = [
-        'scp',
-        '-o', 'UserKnownHostsFile=/dev/null',
-        '-o', 'CheckHostIP=no',
-        '-o', 'StrictHostKeyChecking=no',
-        '-i', expected_ssh_file,
-        '-P', str(expected_port),
-        '--', '%s@%s:%s' % (expected_user, expected_ip, expected_remote_file),
-        expected_local_file
-        ]
-    if LOGGER.level <= logging.DEBUG:
-      expected_command.insert(-5, '-v')
-
-    command.SetFlags(flag_values)
-    mock_instance_resource = {
-        'networkInterfaces': [{'accessConfigs': [{'type': 'ONE_TO_ONE_NAT',
-                                                  'natIP': expected_ip}]}],
-        'status': 'RUNNING'}
-
-    command_line = command._BuildSshCmd(mock_instance_resource, 'scp', scp_args)
-    self.assertEqual(expected_command, command_line)
-
-
-if __name__ == '__main__':
-  unittest.main()