def run_api_tests(self, record=False):
"""Run several API calls."""
if record:
os.environ[replay.RECORD_ENVIRONMENT_VAR] = self.record_file
os.environ[replay.REPLAY_ENVIRONMENT_VAR] = ''
mock_responses = []
mock_responses.append(({'status': '200'},
fake_compute.GET_PROJECT_RESPONSE))
for page in fake_compute.LIST_NETWORKS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
mock_responses.append((
{'status': '403', 'content-type': 'application/json'},
fake_compute.ACCESS_DENIED))
http_mocks.mock_http_response_sequence(mock_responses)
else:
os.environ[replay.RECORD_ENVIRONMENT_VAR] = ''
os.environ[replay.REPLAY_ENVIRONMENT_VAR] = self.record_file
gce_api_client = None
mock_creds = mock.Mock(spec_set=credentials.Credentials)
with mock.patch.object(google.auth, 'default',
return_value=(mock_creds, 'test-project')):
gce_api_client = compute.ComputeClient(
global_configs=self.fake_global_configs)
responses = []
responses.append(gce_api_client.get_project(self.project_id))
responses.append(gce_api_client.get_networks(self.project_id))
try:
gce_api_client.get_instances(self.project_id)
except api_errors.ApiExecutionError as e:
responses.append(str(e))
return responses
def test_cud_firewall_rule_retry(self, name, verb, mock_logger):
"""Test create/patch/update/delete firewall rule times out."""
mock_pending = fake_compute.PENDING_OPERATION_TEMPLATE.format(
verb=verb, resource_path='project1/global/firewalls/fake-firewall')
mock_finished = fake_compute.FINISHED_OPERATION_TEMPLATE.format(
verb=verb, resource_path='project1/global/firewalls/fake-firewall')
mock_responses = [({
'status': '200'
}, mock_pending), ({
'status': '200'
}, mock_pending), ({
'status': '200'
}, mock_pending), ({
'status': '200'
}, mock_finished)]
http_mocks.mock_http_response_sequence(mock_responses)
# Set initial wait to longer than the timeout
with mock.patch.object(self.gce_api_client,
'ESTIMATED_API_COMPLETION_IN_SEC',
return_value=2):
method = getattr(self.gce_api_client,
'{}_firewall_rule'.format(verb))
results = method(self.project_id,
rule=fake_compute.FAKE_FIREWALL_RULE,
blocking=True,
timeout=1,
retry_count=3)
self.assertDictEqual(json.loads(mock_finished), results)
self.assertTrue(mock_logger.warn.called)
def test_export_assets_project_blocking(self):
"""Test export_assets for a project in blocking mode."""
mock_responses = [
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_PROJECT_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_PROJECT_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_PROJECT_RESOURCES_DONE)
]
http_mocks.mock_http_response_sequence(mock_responses)
with mock.patch.object(self.asset_api_client, 'OPERATION_DELAY_IN_SEC',
0.1):
result = self.asset_api_client.export_assets(
fake_cloudasset.PROJECT,
output_config=self.default_output_config,
content_type='RESOURCE',
asset_types=['cloudresourcemanager.googleapis.com/Project'],
blocking=True)
self.assertEqual(
json.loads(fake_cloudasset.EXPORT_ASSETS_PROJECT_RESOURCES_DONE),
result)
def test_export_assets_folder_blocking(self):
"""Test export_assets for a folder in blocking mode."""
mock_responses = [
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_FOLDER_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_FOLDER_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_FOLDER_RESOURCES_DONE)
]
http_mocks.mock_http_response_sequence(mock_responses)
with mock.patch.object(self.asset_api_client, 'OPERATION_DELAY_IN_SEC',
0.1):
result = self.asset_api_client.export_assets(
fake_cloudasset.FOLDER,
fake_cloudasset.DESTINATION,
content_type='RESOURCE',
asset_types=fake_cloudasset.ASSET_TYPES,
blocking=True)
self.assertEqual(
json.loads(fake_cloudasset.EXPORT_ASSETS_FOLDER_RESOURCES_DONE),
result)
def test_export_assets_organization_blocking(self):
"""Test export_assets for an organization in blocking mode."""
mock_responses = [
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_ORGANIZATION_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_ORGANIZATION_RESOURCES_OPERATION),
({
'status': '200'
}, fake_cloudasset.EXPORT_ASSETS_ORGANIZATION_RESOURCES_DONE)
]
http_mocks.mock_http_response_sequence(mock_responses)
with mock.patch.object(self.asset_api_client, 'OPERATION_DELAY_IN_SEC',
0.1):
result = self.asset_api_client.export_assets(
fake_cloudasset.ORGANIZATION,
output_config=self.default_output_config,
content_type='RESOURCE',
blocking=True)
self.assertEqual(
json.loads(
fake_cloudasset.EXPORT_ASSETS_ORGANIZATION_RESOURCES_DONE),
result)
def test_cud_firewall_rule_blocking(self, name, verb):
"""Test create/patch/update/delete firewall blocks until complete."""
mock_pending = fake_compute.PENDING_OPERATION_TEMPLATE.format(
verb=verb, resource_path='project1/global/firewalls/fake-firewall')
mock_finished = fake_compute.FINISHED_OPERATION_TEMPLATE.format(
verb=verb, resource_path='project1/global/firewalls/fake-firewall')
mock_responses = [({
'status': '200'
}, mock_pending), ({
'status': '200'
}, mock_pending), ({
'status': '200'
}, mock_finished)]
http_mocks.mock_http_response_sequence(mock_responses)
# Don't wait for API to complete in test.
with mock.patch.object(self.gce_api_client,
'ESTIMATED_API_COMPLETION_IN_SEC',
return_value=0):
method = getattr(self.gce_api_client,
'{}_firewall_rule'.format(verb))
results = method(self.project_id,
rule=fake_compute.FAKE_FIREWALL_RULE,
blocking=True)
self.assertDictEqual(json.loads(mock_finished), results)
def test_file_not_accessible_in_gcs(self, mock_default_credentials):
"""Test HTTP not 200 results in False."""
mock_responses = [({
'status': '403',
'content-range': '0-10/11'
}, b'{"test": 1}')]
http_mocks.mock_http_response_sequence(mock_responses)
self.assertFalse(file_loader.access('gs://fake/file.json'))
def test_isfile_in_gcs(self, mock_default_credentials):
"""Test HTTP 200 results in True."""
mock_responses = [({
'status': '200',
'content-range': '0-10/11'
}, b'{"test": 1}')]
http_mocks.mock_http_response_sequence(mock_responses)
self.assertTrue(file_loader.isfile('gs://fake/file.json'))
def test_get_networks(self):
"""Test get networks."""
mock_responses = []
for page in fake_compute.LIST_NETWORKS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gce_api_client.get_networks(self.project_id)
self.assertEquals(fake_compute.EXPECTED_NETWORK_NAME,
[r.get('name') for r in results])
def test_get_firewall_rules(self):
"""Test get firewall rules."""
mock_responses = []
for page in fake_compute.LIST_FIREWALLS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gce_api_client.get_firewall_rules(self.project_id)
self.assertEquals(fake_compute.EXPECTED_FIREWALL_NAMES,
[r.get('name') for r in results])
def test_get_backend_services(self):
"""Test get backend services."""
mock_responses = []
for page in fake_compute.LIST_BACKEND_SERVICES_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gce_api_client.get_backend_services(self.project_id)
self.assertEquals(fake_compute.EXPECTED_BACKEND_SERVICES_NAMES,
[r.get('name') for r in results])
def test_get_organizations_multiple_pages(self):
"""Test multiple pages when calling get_organizations()."""
mock_responses = []
for page in fake_crm_responses.SEARCH_ORGANIZATIONS:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.crm_api_client.get_organizations()
self.assertEqual(fake_crm_responses.EXPECTED_ORGANIZATIONS_FROM_SEARCH,
[r.get('name') for r in results])
def test_get_curated_roles(self):
"""Test get iam curated roles."""
mock_responses = []
for page in fake_iam.GET_ROLES_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.iam_api_client.get_curated_roles()
self.assertEqual(fake_iam.EXPECTED_ROLE_NAMES,
[r.get('name') for r in results])
def test_get_bigquery_projectids(self):
"""Test get_bigquery_projectids returns a valid list of project ids."""
mock_responses = []
for page in fbq.PROJECTS_LIST_REQUEST_RESPONSE:
mock_responses.append(({'status': '200'}, json.dumps(page)))
http_mocks.mock_http_response_sequence(mock_responses)
return_value = self.bq_api_client.get_bigquery_projectids()
self.assertListEqual(fbq.PROJECTS_LIST_EXPECTED, return_value)
def test_get_bigquery_projectids_with_no_projects(self):
"""Test that get_bigquery_projectids returns an emptly list."""
mock_responses = []
for page in fbq.PROJECTS_LIST_REQUEST_RESPONSE_EMPTY:
mock_responses.append(({'status': '200'}, json.dumps(page)))
http_mocks.mock_http_response_sequence(mock_responses)
return_value = self.bq_api_client.get_bigquery_projectids()
self.assertListEqual([], return_value)
def test_get_snapshots(self):
"""Test get snapshots."""
mock_responses = []
for page in fake_compute.LIST_SNAPSHOTS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gce_api_client.get_snapshots(self.project_id)
self.assertEquals(fake_compute.EXPECTED_SNAPSHOTS_LIST_NAMES,
frozenset([r.get('name') for r in results]))
def test_get_tables(self):
"""Test get_tables returns tables properly."""
mock_responses = []
for page in fbq.GET_TABLES_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
return_value = self.bq_api_client.get_tables(fbq.PROJECT_IDS[0],
fbq.DATASET_ID)
self.assertListEqual(return_value, fbq.TABLES_GET_EXPECTED)
def test_get_all_apis(self):
"""Tests that get_all_apis returns expected number of results."""
mock_responses = []
for page in fake_sm.LIST_ALL_SERVICES_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
return_value = self.sm_api_client.get_all_apis()
self.assertEqual(fake_sm.EXPECTED_ALL_SERVICES_COUNT,
len(return_value))
def test_read_file_from_gcs_json(self):
"""Test read_file_from_gcs for json."""
mock_responses = [({
'status': '200',
'content-range': '0-10/11'
}, b'{"test": 1}')]
http_mocks.mock_http_response_sequence(mock_responses)
expected_dict = {'test': 1}
return_dict = file_loader._read_file_from_gcs('gs://fake/file.json')
self.assertEqual(expected_dict, return_dict)
def test_get_folder_sinks(self):
"""Test get logging folder sinks."""
mock_responses = []
for page in fake_sd_logging.GET_SINKS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.logging_api_client.get_folder_sinks(
fake_sd_logging.FAKE_FOLDER_ID)
self.assertEqual(fake_sd_logging.EXPECTED_SINK_NAMES,
[r.get('name') for r in results])
def test_get_billing_account_sinks(self):
"""Test get logging billing account sinks."""
mock_responses = []
for page in fake_sd_logging.GET_SINKS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.logging_api_client.get_billing_account_sinks(
fake_sd_logging.FAKE_BILLING_ACCOUNT_ID)
self.assertEquals(fake_sd_logging.EXPECTED_SINK_NAMES,
[r.get('name') for r in results])
def test_read_file_from_gcs_yaml(self, mock_default_credential):
"""Test read_file_from_gcs for yaml."""
mock_responses = [({
'status': '200',
'content-range': '0-6/7'
}, b'test: 1')]
http_mocks.mock_http_response_sequence(mock_responses)
expected_dict = {'test': 1}
return_dict = file_loader._read_file_from_gcs('gs://fake/file.yaml')
self.assertEqual(expected_dict, return_dict)
def test_list_versions(self):
mock_responses = []
for page in fae.LIST_VERSIONS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
response = self.ae_api_client.list_versions(
fae.FAKE_PROJECT_ID, fae.FAKE_SERVICE_ID)
self.assertEqual(fae.EXPECTED_VERSION_NAMES,
[r.get('name') for r in response])
def test_get_subnetworks(self):
"""Test get subnetworks."""
mock_responses = []
for page in fake_compute.SUBNETWORKS_AGGREGATED_LIST:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gce_api_client.get_subnetworks(self.project_id)
self.assertEquals(
fake_compute.EXPECTED_SUBNETWORKS_AGGREGATEDLIST_SELFLINKS,
frozenset([r.get('selfLink') for r in results]))
def test_copy_file_from_gcs(self, mock_default_credentials):
"""Test copying file from GCS works."""
mock_responses = [({
'status': '200',
'content-range': '0-10/11'
}, b'{"test": 1}')]
http_mocks.mock_http_response_sequence(mock_responses)
try:
file_path = file_loader.copy_file_from_gcs('gs://fake/file.json')
with open(file_path, 'rb') as f:
self.assertEqual(b'{"test": 1}', f.read())
finally:
os.unlink(file_path)
def test_get_default_object_acls_user_project(self):
"""Test get default object acls requires user project."""
mock_responses = [
({'status': '400', 'content-type': 'application/json'},
fake_storage.USER_PROJECT_MISSING),
({'status': '200', 'content-type': 'application/json'},
fake_storage.DEFAULT_OBJECT_ACL),
]
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gcs_api_client.get_default_object_acls(
fake_storage.FAKE_BUCKET_NAME)
self.assertEqual(3, len(results))
def test_get_object_iam_policy_user_project(self):
"""Test get object iam policy requires user project."""
mock_responses = [
({'status': '400', 'content-type': 'application/json'},
fake_storage.USER_PROJECT_MISSING),
({'status': '200', 'content-type': 'application/json'},
fake_storage.GET_OBJECT_IAM_POLICY_RESPONSE),
]
http_mocks.mock_http_response_sequence(mock_responses)
results = self.gcs_api_client.get_object_iam_policy(
fake_storage.FAKE_BUCKET_NAME, fake_storage.FAKE_OBJECT_NAME)
self.assertTrue('bindings' in results)
def test_get_buckets(self):
"""Test get buckets."""
mock_responses = []
for page in fake_storage.GET_BUCKETS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
expected_bucket_names = fake_storage.EXPECTED_FAKE_BUCKET_NAMES
results = self.gcs_api_client.get_buckets(
fake_storage.FAKE_PROJECT_NUMBER)
self.assertEqual(expected_bucket_names,
[r.get('name') for r in results])
def test_get_text_file(self):
"""Test get test file returns a valid response."""
mock_responses = [
({'status': '200',
'content-range': '0-2/5'}, b'123'),
({'status': '200',
'content-range': '3-4/5'}, b'45')
]
http_mocks.mock_http_response_sequence(mock_responses)
expected_result = b'12345'
result = self.gcs_api_client.get_text_file(
'gs://{}/{}'.format(fake_storage.FAKE_BUCKET_NAME,
fake_storage.FAKE_OBJECT_NAME))
self.assertEqual(expected_result, result)
def test_get_objects_user_project(self):
"""Test get objects requires user project."""
mock_responses = [
({'status': '400', 'content-type': 'application/json'},
fake_storage.USER_PROJECT_MISSING)]
for page in fake_storage.LIST_OBJECTS_RESPONSES:
mock_responses.append(({'status': '200'}, page))
http_mocks.mock_http_response_sequence(mock_responses)
expected_object_names = fake_storage.EXPECTED_FAKE_OBJECT_NAMES
results = self.gcs_api_client.get_objects(
fake_storage.FAKE_PROJECT_NUMBER)
self.assertEqual(expected_object_names,
[r.get('name') for r in results])
