gcloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,342 @@
+# 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.
+
+"""Commands for interacting with Google Compute Engine persistent disks."""
+
+
+
+import time
+
+
+from google.apputils import app
+from google.apputils import appcommands
+import gflags as flags
+
+from gcutil import command_base
+from gcutil import gcutil_logging
+
+
+FLAGS = flags.FLAGS
+LOGGER = gcutil_logging.LOGGER
+
+
+class DiskCommand(command_base.GoogleComputeCommand):
+  """Base command for working with the disks collection."""
+
+  default_sort_field = 'name'
+  summary_fields = (('name', 'name'),
+                    ('description', 'description'),
+                    ('zone', 'zone'),
+                    ('status', 'status'),
+                    ('source-snapshot', 'sourceSnapshot'),
+                    ('size-gb', 'sizeGb'))
+
+  detail_fields = (('name', 'name'),
+                   ('description', 'description'),
+                   ('creation-time', 'creationTimestamp'),
+                   ('zone', 'zone'),
+                   ('status', 'status'),
+                   ('source-snapshot', 'sourceSnapshot'),
+                   ('size-gb', 'sizeGb'))
+
+  resource_collection_name = 'disks'
+
+  def __init__(self, name, flag_values):
+    super(DiskCommand, self).__init__(name, flag_values)
+
+    flags.DEFINE_string('zone',
+                        None,
+                        'The zone for this request.',
+                        flag_values=flag_values)
+
+  def SetApi(self, api):
+    """Set the Google Compute Engine API for the command.
+
+    Args:
+      api: The Google Compute Engine API used by this command.
+
+    Returns:
+      None.
+
+    """
+    self._disks_api = api.disks()
+    self._zones_api = api.zones()
+
+  def _PrepareRequestArgs(self, disk_name, **other_args):
+    """Gets the dictionary of API method keyword arguments.
+
+    Args:
+      disk_name: The name of the disk.
+      **other_args: Keyword arguments that should be included in the request.
+
+    Returns:
+      Dictionary of keyword arguments that should be passed in the API call,
+      includes all keyword arguments passed in 'other_args' plus
+      common keys such as the name of the resource and the project.
+    """
+
+    kwargs = {
+        'project': self._project,
+        'disk': self.DenormalizeResourceName(disk_name)
+    }
+    if self._IsUsingAtLeastApiVersion('v1beta14') and self._flags.zone:
+      kwargs['zone'] = self._flags.zone
+    for key, value in other_args.items():
+      kwargs[key] = value
+    return kwargs
+
+
+class AddDisk(DiskCommand):
+  """Create new machine disks.
+
+  More than one disk name can be specified. Multiple disks will be created in
+  parallel.
+  """
+
+  positional_args = '<disk-name-1> ... <disk-name-n>'
+  status_field = 'status'
+  _TERMINAL_STATUS = ['READY', 'FAILED']
+
+  def __init__(self, name, flag_values):
+    super(AddDisk, self).__init__(name, flag_values)
+    flags.DEFINE_string('description',
+                        '',
+                        'Disk description.',
+                        flag_values=flag_values)
+    flags.DEFINE_integer('size_gb',
+                         None,
+                         'The size of the persistent disk in GB.',
+                         flag_values=flag_values)
+    flags.DEFINE_string('source_snapshot',
+                        None,
+                        'The source snapshot for this disk.',
+                        flag_values=flag_values)
+    flags.DEFINE_string('source_image',
+                        None,
+                        'The source image for this disk.',
+                        flag_values=flag_values)
+    flags.DEFINE_boolean('wait_until_complete',
+                         False,
+                         'Whether the program should wait until the disk'
+                         ' is restored from snapshot.',
+                         flag_values=flag_values)
+
+  def Handle(self, *disk_names):
+    """Add the specified disks.
+
+    Args:
+      *disk_names: The names of the disks to add.
+
+    Returns:
+      A tuple of (results, exceptions).
+
+    Raises:
+      CommandError: If the command is unsupported in this API version.
+      UsageError: If no disk names are specified.
+    """
+    if not disk_names:
+      raise app.UsageError('Please specify at lease one disk name.')
+
+    self._flags.zone = self._GetZone(self._flags.zone)
+    zone = self.NormalizeTopLevelResourceName(self._project, 'zones',
+                                              self._flags.zone)
+    kind = self._GetResourceApiKind('disk')
+
+    source_image = None
+    if self._flags.source_image:
+      source_image = self.NormalizeGlobalResourceName(
+          self._project,
+          'images',
+          self._flags.source_image)
+    source_snapshot = None
+    if self._flags.source_snapshot:
+      source_snapshot = self.NormalizeGlobalResourceName(
+          self._project,
+          'snapshots',
+          self._flags.source_snapshot)
+
+    kwargs = {}
+
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      kwargs['zone'] = self.DenormalizeResourceName(self._flags.zone)
+
+    requests = []
+    for name in disk_names:
+      disk = {
+          'kind': kind,
+          'name': self.DenormalizeResourceName(name),
+          'description': self._flags.description,
+          'zone': zone,
+          }
+
+      if source_snapshot is not None:
+        disk['sourceSnapshot'] = source_snapshot
+      elif source_image is not None:
+        kwargs['sourceImage'] = source_image
+        if self._flags.size_gb:
+          disk['sizeGb'] = self._flags.size_gb
+      else:
+        disk['sizeGb'] = self._flags.size_gb or 10
+      if self._IsUsingAtLeastApiVersion('v1beta14'):
+        del disk['zone']
+
+      requests.append(self._disks_api.insert(project=self._project,
+                                             body=disk, **kwargs))
+
+    if self._flags.wait_until_complete and not self._flags.synchronous_mode:
+      LOGGER.warn('wait_until_complete specified. Implying synchronous_mode.')
+      self._flags.synchronous_mode = True
+
+    (results, exceptions) = self.ExecuteRequests(requests)
+
+    if self._flags.wait_until_complete:
+      awaiting = results
+      results = []
+      for result in awaiting:
+        if 'error' not in result:
+          result = self._WaitUntilDiskIsComplete(result)
+        results.append(result)
+
+    list_type = 'diskList' if self._flags.synchronous_mode else 'operationList'
+    return (self.MakeListResult(results, list_type), exceptions)
+
+  def _InternalGetDisk(self, disk_name):
+    """A simple implementation of getting current disk state.
+
+    Args:
+      disk_name: the name of the disk to get.
+
+    Returns:
+      Json containing full disk information.
+    """
+    disk_request = self._disks_api.get(**self._PrepareRequestArgs(disk_name))
+    return disk_request.execute()
+
+  def _WaitUntilDiskIsComplete(self, result):
+    """Waits for the disk to complete.
+
+    Periodically polls the server for current disk status. Exits if the
+    status of the disk is READY or FAILED or the maximum waiting timeout
+    has been reached. In both cases returns the last known disk details.
+
+    Args:
+      result: the current state of the disk.
+
+    Returns:
+      Json containing full disk information.
+    """
+    current_status = result[self.status_field]
+    disk_name = result['name']
+    start_time = time.time()
+    LOGGER.info('Will wait for restore for: %d seconds.',
+                self._flags.max_wait_time)
+    while (time.time() - start_time < self._flags.max_wait_time and
+           current_status not in self._TERMINAL_STATUS):
+      LOGGER.info(
+          'Waiting for disk. Current status: %s. Sleeping for %ss.',
+          current_status, self._flags.sleep_between_polls)
+      time.sleep(self._flags.sleep_between_polls)
+      result = self._InternalGetDisk(disk_name)
+      current_status = result[self.status_field]
+    if current_status not in self._TERMINAL_STATUS:
+      LOGGER.warn('Timeout reached. Disk %s has not yet been restored.',
+                  disk_name)
+    return result
+
+
+class GetDisk(DiskCommand):
+  """Get a machine disk."""
+
+  positional_args = '<disk-name>'
+
+  def __init__(self, name, flag_values):
+    super(GetDisk, self).__init__(name, flag_values)
+
+  def Handle(self, disk_name):
+    """Get the specified disk.
+
+    Args:
+      disk_name: The name of the disk to get
+
+    Returns:
+      The result of getting the disk.
+    """
+    if self._IsUsingAtLeastApiVersion('v1beta14') and not self._flags.zone:
+      self._flags.zone = self.GetZoneForResource(self._disks_api,
+                                                 disk_name)
+
+    disk_request = self._disks_api.get(**self._PrepareRequestArgs(disk_name))
+    return disk_request.execute()
+
+
+class DeleteDisk(DiskCommand):
+  """Delete one or more machine disks.
+
+  If multiple disk names are specified, the disks will be deleted in parallel.
+  """
+
+  positional_args = '<disk-name-1> ... <disk-name-n>'
+  safety_prompt = 'Delete disk'
+
+  def __init__(self, name, flag_values):
+    super(DeleteDisk, self).__init__(name, flag_values)
+
+  def Handle(self, *disk_names):
+    """Delete the specified disks.
+
+    Args:
+      *disk_names: The names of the disks to delete
+
+    Returns:
+      Tuple (results, exceptions) - result of deleting the disks.
+    """
+    if self._IsUsingAtLeastApiVersion('v1beta14') and not self._flags.zone:
+      if len(disk_names) > 1:
+        self._flags.zone = self._GetZone()
+      else:
+        self._flags.zone = self.GetZoneForResource(self._disks_api,
+                                                   disk_names[0])
+    requests = []
+    for disk_name in disk_names:
+      requests.append(self._disks_api.delete(
+          **self._PrepareRequestArgs(disk_name)))
+    results, exceptions = self.ExecuteRequests(requests)
+    return (self.MakeListResult(results, 'operationList'), exceptions)
+
+
+class ListDisks(DiskCommand, command_base.GoogleComputeListCommand):
+  """List the disks for a project."""
+
+  is_global_level_collection = False
+  is_zone_level_collection = True
+
+  def __init__(self, name, flag_values):
+    super(ListDisks, self).__init__(name, flag_values)
+
+  def ListFunc(self):
+    """Returns the function for listing disks."""
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      return None
+    return self._disks_api.list
+
+  def ListZoneFunc(self):
+    """Returns the function for listing disks in a zone."""
+    return self._disks_api.list
+
+
+def AddCommands():
+  appcommands.AddCmd('adddisk', AddDisk)
+  appcommands.AddCmd('getdisk', GetDisk)
+  appcommands.AddCmd('deletedisk', DeleteDisk)
+  appcommands.AddCmd('listdisks', ListDisks)

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

@@ -0,0 +1,474 @@
+#!/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 persistent disk commands."""
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import copy
+import sys
+
+from google.apputils import app
+import gflags as flags
+import unittest
+
+from gcutil import command_base
+from gcutil import disk_cmds
+from gcutil import mock_api
+
+
+FLAGS = flags.FLAGS
+
+
+class DiskCmdsTest(unittest.TestCase):
+
+  def _DoTestAddDiskGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    expected_description = 'test disk'
+    submitted_zone = 'copernicus-moon-base'
+    expected_size = 20
+    flag_values.service_version = service_version
+    flag_values.zone = submitted_zone
+    flag_values.project = expected_project
+    flag_values.size_gb = expected_size
+    flag_values.description = expected_description
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project,
+        'zones',
+        submitted_zone)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_disk)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sizeGb'], expected_size)
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, result['zone'])
+      self.assertFalse('zone' in result['body'])
+    else:
+      self.assertEqual(result['body']['zone'], expected_zone)
+      self.assertFalse('zone' in result)
+
+  def testAddDiskGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddDiskGeneratesCorrectRequest(version)
+
+  def _DoTestAddMultipleDisks(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_kind = command._GetResourceApiKind('disk')
+    expected_project = 'test_project'
+    expected_disks = ['test-disk-%02d' % i for i in xrange(100)]
+    expected_description = 'test disk'
+    submitted_zone = 'copernicus-moon-base'
+    expected_size = 12
+
+    flag_values.service_version = service_version
+    flag_values.zone = submitted_zone
+    flag_values.project = expected_project
+    flag_values.size_gb = expected_size
+    flag_values.description = expected_description
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project, 'zones', submitted_zone)
+
+    results, exceptions = command.Handle(*expected_disks)
+    self.assertEqual(exceptions, [])
+    results = results['items']
+    self.assertEqual(len(results), len(expected_disks))
+
+    for expected_disk, result in zip(expected_disks, results):
+      self.assertEqual(result['project'], expected_project)
+      self.assertEqual(result['body']['kind'], expected_kind)
+      self.assertEqual(result['body']['sizeGb'], expected_size)
+      self.assertEqual(result['body']['name'], expected_disk)
+      self.assertEqual(result['body']['description'], expected_description)
+      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 testAddMultipleDisks(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddMultipleDisks(version)
+
+  def _DoTestAddDiskFromSnapshotGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    expected_description = 'test disk'
+    submitted_zone = 'copernicus-moon-base'
+    submitted_source_snapshot = 'snap1'
+    flag_values.service_version = service_version
+    flag_values.zone = submitted_zone
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+    flag_values.source_snapshot = submitted_source_snapshot
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project,
+        'zones',
+        submitted_zone)
+
+    expected_source_snapshot = command.NormalizeGlobalResourceName(
+        expected_project,
+        'snapshots',
+        submitted_source_snapshot)
+    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(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_disk)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sourceSnapshot'], expected_source_snapshot)
+
+  def testAddDiskFromSnapshotGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddDiskFromSnapshotGeneratesCorrectRequest(version)
+
+  def testAddDiskDefaultSizeGb(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    flag_values.zone = 'copernicus-moon-base'
+    flag_values.project = 'test_project'
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle('disk1')
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    # We did not set the size, make sure it defaults to 10GB.
+    self.assertEqual(10, result['body']['sizeGb'])
+
+  def testAddDiskFromImageDoesNotPassSizeGbUnlessExplicitlySet(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    flag_values.zone = 'copernicus-moon-base'
+    flag_values.project = 'test_project'
+    flag_values.source_image = 'image1'
+    flag_values.service_version = 'v1beta14'
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle('disk1')
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    # Make sure we did not pass 'sizeGb' in the body.
+    self.assertFalse('sizeGb' in result['body'])
+
+  def _DoTestAddDiskFromImageGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    expected_description = 'test disk'
+    expected_size_gb = 123
+    submitted_zone = 'copernicus-moon-base'
+    submitted_source_image = 'image1'
+    submitted_size_gb = 123
+    flag_values.zone = submitted_zone
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+    flag_values.source_image = submitted_source_image
+    flag_values.size_gb = submitted_size_gb
+    flag_values.service_version = service_version
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project,
+        'zones',
+        submitted_zone)
+
+    expected_source_image = command.NormalizeGlobalResourceName(
+        expected_project,
+        'images',
+        submitted_source_image)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_disk)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sizeGb'], expected_size_gb)
+    self.assertEqual(result['sourceImage'], expected_source_image)
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, result['zone'])
+      self.assertFalse('zone' in result['body'])
+    else:
+      self.assertEqual(result['body']['zone'], expected_zone)
+      self.assertFalse('zone' in result)
+
+  def testAddDiskFromImageGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddDiskFromImageGeneratesCorrectRequest(version)
+
+  def testAddDiskWithKernelGeneratesCorrectRequest(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    expected_description = 'test disk'
+    expected_size_gb = 123
+    submitted_zone = 'copernicus-moon-base'
+    submitted_size_gb = 123
+    flag_values.zone = submitted_zone
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+    flag_values.size_gb = submitted_size_gb
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project,
+        'zones',
+        submitted_zone)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_disk)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sizeGb'], expected_size_gb)
+    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 testAddDiskRequiresZone(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    expected_description = 'test disk'
+    expected_size = 20
+    submitted_version = command_base.CURRENT_VERSION
+    submitted_zone = 'us-east-a'
+
+    flag_values.service_version = submitted_version
+    flag_values.project = expected_project
+    flag_values.size_gb = expected_size
+    flag_values.description = expected_description
+
+    command.SetFlags(flag_values)
+
+    zones = {'items': [{'name': 'us-east-a'},
+                       {'name': 'us-east-b'},
+                       {'name': 'us-east-c'},
+                       {'name': 'us-west-a'}]}
+
+    class MockZonesApi(object):
+      def list(self, **unused_kwargs):
+        return mock_api.MockRequest(zones)
+
+    api = mock_api.MockApi()
+    api.zones = MockZonesApi
+    command.SetApi(api)
+    command._credential = mock_api.MockCredential()
+
+    expected_zone = command.NormalizeTopLevelResourceName(
+        expected_project,
+        'zones',
+        submitted_zone)
+
+    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
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    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)
+
+    sys.stdin = oldin
+    sys.stdout = oldout
+
+  def _DoTestGetDiskGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.GetDisk('getdisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+    flag_values.zone = 'zone-a'
+
+    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_disk)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['disk'], expected_disk)
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, result['zone'])
+    else:
+      self.assertFalse('zone' in result)
+
+  def testGetDiskGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestGetDiskGeneratesCorrectRequest(version)
+
+  def _DoTestDeleteDiskGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = disk_cmds.DeleteDisk('deletedisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disk = 'test_disk'
+    flag_values.project = expected_project
+    flag_values.zone = 'zone-a'
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    flag_values.service_version = service_version
+    submitted_zone = 'copernicus-moon-base'
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      flag_values.zone = submitted_zone
+
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_disk)
+    self.assertEqual(len(results['items']), 1)
+    self.assertEqual(exceptions, [])
+    result = results['items'][0]
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['disk'], expected_disk)
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, result['zone'])
+    else:
+      self.assertFalse('zone' in result)
+
+  def testDeleteDiskGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestDeleteDiskGeneratesCorrectRequest(version)
+
+  def testDeleteMultipleDisks(self):
+    flag_values = copy.deepcopy(FLAGS)
+    command = disk_cmds.DeleteDisk('deletedisk', flag_values)
+
+    expected_project = 'test_project'
+    expected_disks = ['test-disk-%02d' % x for x in xrange(100)]
+    flag_values.project = expected_project
+    flag_values.zone = 'zone-a'
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(*expected_disks)
+    self.assertEqual(exceptions, [])
+    results = results['items']
+    self.assertEqual(len(results), len(expected_disks))
+
+    for expected_disk, result in zip(expected_disks, results):
+      self.assertEqual(result['project'], expected_project)
+      self.assertEqual(result['disk'], expected_disk)
+
+  def testAddWithNoDisk(self):
+    flag_values = copy.deepcopy(FLAGS)
+    command = disk_cmds.AddDisk('adddisk', flag_values)
+    self.assertRaises(app.UsageError, command.Handle)
+
+
+if __name__ == '__main__':
+  unittest.main()