gcloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,84 @@
+#!/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 metadata package."""
+
+from __future__ import with_statement
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import copy
+import tempfile
+
+from google.apputils import app
+import gflags as flags
+import unittest
+
+from gcutil import metadata
+
+
+FLAGS = flags.FLAGS
+
+
+class MetadataTest(unittest.TestCase):
+
+  def testGatherMetadata(self):
+    flag_values = copy.deepcopy(FLAGS)
+    metadata_flags_processor = metadata.MetadataFlagsProcessor(flag_values)
+
+    with tempfile.NamedTemporaryFile() as metadata_file:
+      metadata_file.write('metadata file content')
+      metadata_file.flush()
+
+      flag_values.metadata = ['bar:baz']
+      flag_values.metadata_from_file = ['bar_file:%s' % metadata_file.name]
+
+      metadata_entries = metadata_flags_processor.GatherMetadata()
+
+      self.assertEqual(len(metadata_entries), 2)
+      self.assertEqual(metadata_entries[0]['key'], 'bar')
+      self.assertEqual(metadata_entries[0]['value'], 'baz')
+      self.assertEqual(metadata_entries[1]['key'], 'bar_file')
+      self.assertEqual(metadata_entries[1]['value'],
+                       'metadata file content')
+
+  def testGatherMetadataWithDuplicateKeys(self):
+    flag_values = copy.deepcopy(FLAGS)
+    metadata_flags_processor = metadata.MetadataFlagsProcessor(flag_values)
+
+    flag_values.metadata = ['bar:baz', 'bar:foo']
+    self.assertRaises(app.UsageError, metadata_flags_processor.GatherMetadata)
+
+    flag_values.metadata = ['bar:baz', 'bar:foo', 'foo:baz', 'foobar:val']
+    self.assertRaises(app.UsageError, metadata_flags_processor.GatherMetadata)
+
+    flag_values.metadata = ['foo:foo', 'bar:baz', 'bar:foo', 'foo:baz',
+                            'foobar:val']
+    self.assertRaises(app.UsageError, metadata_flags_processor.GatherMetadata)
+
+    with tempfile.NamedTemporaryFile() as metadata_file:
+      metadata_file.write('metadata file content')
+      metadata_file.flush()
+      flag_values.metadata = ['bar:baz']
+      flag_values.metadata_from_file = ['bar:%s' % metadata_file.name]
+      self.assertRaises(app.UsageError, metadata_flags_processor.GatherMetadata)
+
+
+if __name__ == '__main__':
+  unittest.main()

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

@@ -0,0 +1,420 @@
+# 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.
+
+"""Mock Google Compute Engine API used for unit tests."""
+
+
+
+
+
+import inspect
+
+
+class CommandExecutor(object):
+  """An object to represent an apiclient endpoint with a fixed response."""
+
+  def __init__(self, response):
+    """Create a new CommandExecutor to return response for each API call."""
+    self._response = response
+
+  def __call__(self, **unused_kw):
+    """Handle calling this object (part 1 of making an apiclient call)."""
+    self._parameters = unused_kw
+    return self
+
+  def execute(self):
+    """Return the stored results for this API call (part 2 of apiclient)."""
+    return self._response
+
+
+class MockRequest(object):
+  """Mock request type for use with the MockApi class."""
+
+  def __init__(self, payload, method_name=None):
+    self.request_payload = payload
+    # For now we return the request as a response.
+    self.result_payload = payload
+    self.method_name = method_name
+
+  def execute(self, http=None):  # pylint: disable-msg=W0613
+    return self.result_payload
+
+
+class MockApiBase(object):
+  """Base class for all mock APIs."""
+
+  def __init__(self):
+    self.requests = []
+
+  def RegisterRequest(self, request_data, **kwargs):
+    if kwargs:
+      request_data = dict(request_data.items() + kwargs.items())
+    request = MockRequest(request_data, inspect.stack()[1][3])
+    self.requests.append(request)
+    return request
+
+
+class MockDisksApi(MockApiBase):
+  """Mock return result of the MockApi.disks() method."""
+
+  def get(self, project='wrong_project', disk='wrong_disk', **kwargs):
+    return self.RegisterRequest({'project': project, 'disk': disk}, **kwargs)
+
+  def insert(self, project='wrong_project', body='wrong_disk_resource',
+             sourceImage='wrong_source_image', **kwargs):
+    return self.RegisterRequest({'project': project, 'body': body,
+                                 'sourceImage': sourceImage}, **kwargs)
+
+  def delete(self, project='wrong_project', disk='wrong_disk', **kwargs):
+    return self.RegisterRequest({'project': project, 'disk': disk}, **kwargs)
+
+  def list(self, project='wrong_project', zone='wrong_zone', **kwargs):
+    return self.RegisterRequest({'project': project, 'zone': zone}, **kwargs)
+
+
+class MockFirewallsApi(MockApiBase):
+  """Mock return result of the MockApi.firewalls() method."""
+
+  def get(self, project='wrong_project', firewall='wrong_firewall'):
+    return self.RegisterRequest({'project': project, 'firewall': firewall})
+
+  def insert(self, project='wrong_project', body='wrong_firewall_resource'):
+    return self.RegisterRequest({'project': project, 'body': body})
+
+  def delete(self, project='wrong_project', firewall='wrong_firewall'):
+    return self.RegisterRequest({'project': project, 'firewall': firewall})
+
+  def list(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+
+class MockBackendGroupsApi(MockApiBase):
+  """Mock return result of the MockApi.backendGroups() method."""
+
+  def get(self, project='wrong_project', backendGroup='wrong_backend_group',
+          **kwargs):
+    return self.RegisterRequest({'project': project,
+                                 'backendGroup': backendGroup}, **kwargs)
+
+  def insert(self, project='wrong_project',
+             body='wrong_backend_group_resource', **kwargs):
+    return self.RegisterRequest({'project': project, 'body': body}, **kwargs)
+
+  def delete(self, project='wrong_project', backendGroup='wrong_backend_group',
+             **kwargs):
+    return self.RegisterRequest({'project': project,
+                                 'backendGroup': backendGroup}, **kwargs)
+
+  def list(self, project='wrong_project', **kwargs):
+    return self.RegisterRequest({'project': project}, **kwargs)
+
+
+class MockPublicEndpointsApi(MockApiBase):
+  """Mock return result of the MockApi.publicEndpoints() method."""
+
+  def get(self, project='wrong_project',
+          publicEndpoint='wrong_public_endpoint'):
+    return self.RegisterRequest({'project': project,
+                                 'publicEndpoint': publicEndpoint})
+
+  def insert(self, project='wrong_project',
+             body='wrong_public_endpoint_resource'):
+    return self.RegisterRequest({'project': project, 'body': body})
+
+  def delete(self, project='wrong_project',
+             publicEndpoint='wrong_public_endpoint'):
+    return self.RegisterRequest({'project': project,
+                                 'publicEndpoint': publicEndpoint})
+
+  def list(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+
+class MockNetworksApi(MockApiBase):
+  """Mock return result of the MockApi.networks() method."""
+
+  def get(self, project='wrong_project', network='wrong_network'):
+    return self.RegisterRequest({'project': project, 'network': network})
+
+  def insert(self, project='wrong_project', body='wrong_network_resource'):
+    return self.RegisterRequest({'project': project, 'body': body})
+
+  def delete(self, project='wrong_project', network='wrong_network'):
+    return self.RegisterRequest({'project': project, 'network': network})
+
+  def list(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+
+class MockGlobalOperationsApi(MockApiBase):
+  """Mock return result of the MockApi.globalOperations() method."""
+
+  def get(self, project='wrong_project', operation='wrong_operation', **kwargs):
+    return self.RegisterRequest({'project': project, 'operation': operation},
+                                **kwargs)
+
+  def delete(self, project='wrong_project', operation='wrong_operation'):
+    return self.RegisterRequest({'project': project, 'operation': operation})
+
+  def list(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+
+class MockZoneOperationsApi(MockApiBase):
+  """Mock return result of the MockApi.zoneOperations() method."""
+
+  def get(self, project='wrong_project', operation='wrong_operation',
+          zone='wrong_zone'):
+    return self.RegisterRequest({'project': project,
+                                 'operation': operation,
+                                 'zone': zone})
+
+  def delete(self, project='wrong_project', operation='wrong_operation',
+             zone='wrong_zone'):
+    return self.RegisterRequest({'project': project,
+                                 'operation': operation,
+                                 'zone': zone})
+
+  def list(self, project='wrong_project', zone='wrong_zone'):
+    return self.RegisterRequest({'project': project, 'zone': zone})
+
+
+class MockImagesApi(MockApiBase):
+  """Mock return result of the MockApi.images() method."""
+
+  def get(self, project='wrong_project', image='wrong_image'):
+    return self.RegisterRequest({'project': project, 'image': image})
+
+  def insert(self, project='wrong_project', body='wrong_image_resource'):
+    return self.RegisterRequest({'project': project, 'body': body})
+
+  def delete(self, project='wrong_project', image='wrong_image'):
+    return self.RegisterRequest({'project': project, 'image': image})
+
+  def list(self, project='wrong_project', **unused_kwargs):
+    return self.RegisterRequest({'project': project})
+
+  def deprecate(self, project='wrong_project', image='wrong_image',
+                body='wrong_deprecation_resource'):
+    return self.RegisterRequest({'project': project, 'image': image,
+                                 'body': body})
+
+
+class MockInstancesApi(MockApiBase):
+  """Mock return result of the MockApi.instances() method."""
+
+  def get(self, project='wrong_project', instance='wrong_instance', **kwargs):
+    return self.RegisterRequest({'project': project, 'instance': instance},
+                                **kwargs)
+
+  def insert(self, project='wrong_project', body='wrong_instance_resource',
+             **kwargs):
+    return self.RegisterRequest({'project': project, 'body': body}, **kwargs)
+
+  def delete(self, project='wrong_project', instance='wrong_instance',
+             **kwargs):
+    return self.RegisterRequest({'project': project, 'instance': instance},
+                                **kwargs)
+
+  def list(self, project='wrong_project', zone='wrong_zone', **unused_kwargs):
+    return self.RegisterRequest({'project': project, 'zone': zone})
+
+  def addAccessConfig(self, project='wrong_project', instance='wrong_instance',
+                      network_interface='wrong_network_interface',
+                      body='wrong_instance_resource', **kwargs):
+    return self.RegisterRequest({'project': project, 'instance': instance,
+                                 'network_interface': network_interface,
+                                 'body': body}, **kwargs)
+
+  def deleteAccessConfig(self, project='wrong_project',
+                         instance='wrong_instance',
+                         network_interface='wrong_network_interface',
+                         access_config='wrong_access_config',
+                         **kwargs):
+    return self.RegisterRequest({'project': project, 'instance': instance,
+                                 'network_interface': network_interface,
+                                 'access_config': access_config}, **kwargs)
+
+  def setMetadata(self, project='wrong_project', instance='wrong_instance',
+                  body='wrong_metadata', zone='wrong_zone'):
+    return self.RegisterRequest({'project': project, 'instance': instance,
+                                 'body': body, 'zone': zone})
+
+  def setTags(self, project='wrong_project', instance='wrong_instance',
+              body='wrong_tags', zone='wrong_zone'):
+    return self.RegisterRequest({'project': project, 'instance': instance,
+                                 'body': body, 'zone': zone})
+
+
+class MockKernelsApi(MockApiBase):
+  """Mock return result of the MockApi.kernels() method."""
+
+  def get(self, project='wrong_project', kernel='wrong_kernel'):
+    return self.RegisterRequest({'project': project, 'kernel': kernel})
+
+  def list(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+
+class MockMachineSpecsApi(MockApiBase):
+  """Mock return result of the MockApi.machineSpecs() method."""
+
+  def get(self, machineSpec='wrong_machine_type'):
+    return self.RegisterRequest({'machineSpec': machineSpec})
+
+  def list(self):
+    return self.RegisterRequest('empty_result')
+
+
+class MockMachineTypesApi(MockApiBase):
+  """Mock return result of the MockApi.machineTypes() method."""
+
+  def get(self, machineType='wrong_machine_type', **unused_kwargs):
+    return self.RegisterRequest({'machineType': machineType})
+
+  def list(self, **unused_kwargs):
+    return self.RegisterRequest('empty_result')
+
+
+class MockProjectsApi(MockApiBase):
+  """Mock return result of the MockApi.projects() method."""
+
+  def get(self, project='wrong_project'):
+    return self.RegisterRequest({'project': project})
+
+  def setCommonInstanceMetadata(self, project='wrong_project', body=None):
+    return self.RegisterRequest({'project': project,
+                                 'commonInstanceMetadata': body})
+
+
+class MockSnapshotsApi(MockApiBase):
+  """Mock return result of the MockApi.snapshots() method."""
+
+  def get(self, project='wrong_project', snapshot='wrong_snapshot', **kwargs):
+    return self.RegisterRequest({'project': project, 'snapshot': snapshot},
+                                **kwargs)
+
+  def insert(self, project='wrong_project', body='wrong_snapshot_resource',
+             **kwargs):
+    return self.RegisterRequest({'project': project, 'body': body}, **kwargs)
+
+  def delete(self, project='wrong_project', snapshot='wrong_snapshot',
+             **kwargs):
+    return self.RegisterRequest({'project': project, 'snapshot': snapshot},
+                                **kwargs)
+
+  def list(self, project='wrong_project', **kwargs):
+    return self.RegisterRequest({'project': project}, **kwargs)
+
+
+class MockZonesApi(MockApiBase):
+  """Mock return result of the MockApi.zones() method."""
+
+  def get(self, zone='wrong_zone', **unused_kwargs):
+    return self.RegisterRequest({'zone': zone})
+
+  def list(self, **unused_kwargs):
+    return self.RegisterRequest('empty_result')
+
+
+class MockApi(object):
+  """Mock of the Google Compute Engine API returned by the discovery client."""
+
+  def disks(self):
+    return MockDisksApi()
+
+  def firewalls(self):
+    return MockFirewallsApi()
+
+  def backendGroups(self):
+    return MockBackendGroupsApi()
+
+  def publicEndpoints(self):
+    return MockPublicEndpointsApi()
+
+  def networks(self):
+    return MockNetworksApi()
+
+  def images(self):
+    return MockImagesApi()
+
+  def instances(self):
+    return MockInstancesApi()
+
+  def kernels(self):
+    return MockKernelsApi()
+
+  def machineSpecs(self):
+    return MockMachineSpecsApi()
+
+  def machineTypes(self):
+    return MockMachineTypesApi()
+
+  def projects(self):
+    return MockProjectsApi()
+
+  def operations(self):
+    return MockGlobalOperationsApi()
+
+  def zoneOperations(self):
+    return MockZoneOperationsApi()
+
+  def globalOperations(self):
+    return MockGlobalOperationsApi()
+
+  def snapshots(self):
+    return MockSnapshotsApi()
+
+  def zones(self):
+    return MockZonesApi()
+
+
+class MockOutput(object):
+  """Mock class used for capturing standard output in tests."""
+
+  def __init__(self):
+    self._capture_text = ''
+
+  # Purposefully name this 'write' to mock an output stream
+  # pylint: disable-msg=C6409
+  def write(self, text):
+    self._capture_text += text
+
+  # Purposefully name this 'flush' to mock an output stream
+  # pylint: disable-msg=C6409
+  def flush(self):
+    pass
+
+  def GetCapturedText(self):
+    return self._capture_text
+
+
+class MockInput(object):
+  """Mock class for standard input in tests."""
+
+  def __init__(self, input_string):
+    self._input_string = input_string
+
+  # Purposefully name this 'readline' to mock an input stream
+  # pylint: disable-msg=C6409
+  def readline(self):
+    return self._input_string
+
+
+class MockCredential(object):
+  """A mock credential that does nothing."""
+
+  def authorize(self, http):
+    return http
+