def _init_client(self, service_name, api_version=None):
client = get_client(service_name=service_name,
api_version=api_version,
region_id=self.region_id,
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
config=self.init_client_config())
return client
def test_empty(self):
# TODO: util describe_regions raise
os.environ.pop('ALIBABA_CLOUD_CREDENTIALS_FILE')
client = get_client('ecs')
try:
client.describe_regions()
assert False
except NoCredentialsException as e:
self.assertEqual(e.error_message, 'Unable to locate credentials')
def test_file_ak_1(self):
credentials_file = ('[default]\n' 'enable\n')
self.write_config(credentials_file)
try:
client = get_client('ecs')
assert False
except ClientException as e:
self.assertTrue(e.error_message.startswith('Credentials file'))
self.assertTrue(e.error_message.endswith('format is incorrect.'))
def status_verify(self, instance):
client = alibabacloud.get_client(service_name='ecs', access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id=self.region_id)
response = client.describe_instances(instance_ids=json.dumps([instance.instance_id]))
obj = response['Instances']['Instance'][0]
for key, value in iteritems(obj):
attr_name = self._convert_camel_to_snake(key)
self.assertTrue(hasattr(instance, attr_name), "instance has no " + attr_name)
self.assertEqual(obj[key], getattr(instance, attr_name))
def test_ecs_client(self):
client = alibabacloud.get_client(
service_name='Ecs',
api_version='2014-05-26',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id=self.region_id)
self.assertTrue(isinstance(client, EcsClient))
result = client.describe_regions()
self.assertTrue(result.get('Regions'))
def test_not_support_client(self):
try:
client = alibabacloud.get_client(
service_name='Ems',
api_version='2014-05-26',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id=self.region_id)
assert False
except ServiceNameInvalidException as e:
self.assertTrue(e.error_message, 'No such service_name Ems')
def test_file_ak_3(self):
credentials_file = ('[default]\n' 'type = access_key\n')
self.write_config(credentials_file)
try:
client = get_client('ecs')
assert False
except PartialCredentialsException as e:
self.assertEqual(
e.error_message,
'Partial credentials found in profile, access_key_id is empty')
def test_file_rsa_key_pair(self):
credentials_file = ('[default]\n'
'type = rsa_key_pair\n'
'rsa_key_pair = rsa_key_pair\n')
self.write_config(credentials_file)
try:
client = get_client('ecs', region_id='cn-hangzhou')
assert False
except ClientException as e:
self.assertEqual(e.error_message,
'RSA Key Pair credentials are not supported.')
def test_rpc_regions_request_with_error(self):
self.client_config.region_id = 'abc'
ecs_client = get_client(service_name='ecs',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
config=self.client_config)
with self.assertRaises(InvalidRegionIDException) as e:
ecs_client.describe_regions()
self.assertEqual(
e.exception.error_message, "No such region 'abc'."
" Please check your region ID.")
def test_instance_env(self):
os.environ.pop('ALIBABA_CLOUD_CREDENTIALS_FILE')
os.environ['ALIBABA_CLOUD_ROLE_NAME'] = 'EcsRamRoleTest'
client = get_client('ecs')
try:
client.describe_regions()
assert False
except ConnectionUsingEcsRamRoleException as e:
self.assertEqual(
e.error_message,
'Max number of attempts exceeded when attempting to retrieve data from metadata service.May you need to check your ecs instance'
)
os.environ.pop('ALIBABA_CLOUD_ROLE_NAME')
def test_env_default_client_2(self):
os.environ.setdefault("ALIBABA_CLOUD_ACCESS_KEY_ID", "123")
try:
client = get_client('ecs')
assert False
except PartialCredentialsException as e:
self.assertEqual(
e.error_message,
'Partial credentials found in env, ALIBABA_CLOUD_ACCESS_KEY_SECRET is empty'
)
os.environ.pop("ALIBABA_CLOUD_ACCESS_KEY_ID")
def test_file_beartoken(self):
credentials_file = ('[default]\n'
'type = bearer_token\n'
'bearer_token = bearer_token\n')
self.write_config(credentials_file)
client = get_client('ecs', region_id='cn-hangzhou')
try:
client.describe_regions()
assert False
except ServerException as e:
self.assertEqual(e.error_code, 'UnsupportedSignatureType')
self.assertEqual(e.error_message,
'This signature type is not supported.')
def test_not_support_version(self):
try:
client = alibabacloud.get_client(
service_name='ECS',
api_version='2015-05-26',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id=self.region_id)
assert False
except ApiVersionInvalidException as e:
self.assertTrue(
e.error_message,
"ECS no such api_version '2015-05-26'. Please check your API Version.\n"
"We now support api_version: 2014-05-26")
def test_file_retry(self):
config_file = ('[default]\n'
'max_retry_times = 2\n'
'endpoint = somewhere.you.will.never.get\n'
'region_id = us-west-1\n')
self.write_config(config_file)
api_request = APIRequest('DescribeInstances', 'GET', 'http', 'RPC')
client = get_client(
'ecs', credentials_provider=self.init_credentials_provider())
globals()["_test_compute_delay"] = []
def record_sleep(delay):
global _test_compute_delay
_test_compute_delay.append(delay)
from alibabacloud.handlers.api_protocol_handler import APIProtocolHandler
from alibabacloud.handlers.credentials_handler import CredentialsHandler
from alibabacloud.handlers.signer_handler import SignerHandler
from alibabacloud.handlers.timeout_config_reader import TimeoutConfigReader
from alibabacloud.handlers.endpoint_handler import EndpointHandler
from alibabacloud.handlers.retry_handler import RetryHandler
from alibabacloud.handlers.server_error_handler import ServerErrorHandler
from alibabacloud.handlers.http_handler import HttpHandler
DEFAULT_HANDLERS = [
RetryHandler(),
APIProtocolHandler(),
CredentialsHandler(),
SignerHandler(),
TimeoutConfigReader(),
EndpointHandler(),
ServerErrorHandler(),
HttpHandler(),
]
client.handlers = DEFAULT_HANDLERS
with patch.object(time, "sleep", wraps=record_sleep) as monkey:
try:
client._handle_request(api_request)
assert False
except HttpErrorException as e:
self.assertTrue(
"Max retries exceeded with url" in e.error_message)
self.assertEqual(2, monkey.call_count)
self.assertEqual(2, len(_test_compute_delay))
os.environ.pop('ALIBABA_CLOUD_CONFIG_FILE')
def test_file_ecs_ram_role(self):
credentials_file = ('[default]\n'
'type = ecs_ram_role\n'
'role_name = EcsRamRoleTest\n')
self.write_config(credentials_file)
client = get_client('ecs')
try:
client.describe_regions()
assert False
except ConnectionUsingEcsRamRoleException as e:
self.assertEqual(
e.error_message,
'Max number of attempts exceeded when attempting to retrieve data from metadata service.May you need to check your ecs instance'
)
def test_file_ak(self):
# credentials file no default raise PartialCredentialsException
credentials_file = ('[default1]\n'
'enable = true\n'
'type = access_key\n')
self.write_config(credentials_file)
try:
client = get_client('ecs')
assert False
except PartialCredentialsException as e:
self.assertEqual(
e.error_message,
'Partial credentials found in profile, default section is empty'
)
def test_file_region_id(self):
config_file = ('[default]\n'
'region_id = us-west-1\n'
'endpoint = somewhere.you.will.never.get\n')
self.write_config(config_file)
client = get_client('ecs',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret)
self.assertEqual(client.config.region_id, 'us-west-1')
self.assertEqual(client.config.endpoint,
'somewhere.you.will.never.get')
self.assertEqual(client.config.max_retry_times, 3)
self.assertEqual(client.config.http_port, 80)
self.assertEqual(client.config.https_port, 443)
self.assertEqual(client.config.connection_timeout, None)
self.assertEqual(client.config.read_timeout, None)
os.environ.pop('ALIBABA_CLOUD_CONFIG_FILE')
def test_file_sts_token(self):
credentials_file = ('[default]\n'
'type = sts_token\n'
'access_key_id = STS.access_key_id\n'
'access_key_secret = STS.access_key_secret\n'
'security_token = alice\n')
self.write_config(credentials_file)
client = get_client('ecs')
try:
client.describe_regions()
assert False
except ServerException as e:
self.assertEqual(e.http_status, 400)
self.assertEqual(e.error_code, 'InvalidParameter')
self.assertEqual(
e.error_message,
'The specified parameter "SecurityToken.Malformed" is not valid.'
)
def test_file_ca(self):
self.tempdir = tempfile.mkdtemp()
self.credentials_file = os.path.join(self.tempdir, 'config')
os.environ['ALIBABA_CLOUD_CONFIG_FILE'] = self.credentials_file
config_file = ('[default]\n'
'region_id = us-west-1\n'
'endpoint = somewhere.you.will.never.get\n'
'verify = /path/cacerts.pem\n')
self.write_config(config_file)
client = get_client('ecs',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id='hangzhou',
endpoint='123')
self.assertEqual(client.config.verify, "/path/cacerts.pem")
shutil.rmtree(self.tempdir)
os.environ.pop('ALIBABA_CLOUD_CONFIG_FILE')
def test_instance_full_status(self):
def mock_do_request(client):
class MockData:
def __init__(_self):
_self.result = self._read_mock_data(
"instance_full_status.json")
return MockData()
from alibabacloud import get_client
from alibabacloud.services.ecs import ECSResource
ecs_client = get_client('ecs')
with patch.object(ecs_client, "_handle_request", mock_do_request):
ecs = ECSResource(_client=ecs_client)
statuses = list(ecs.instance_full_statuses.all())
self.assertEqual(2, len(statuses))
status = statuses[0]
self.assertEqual("i-instance1", status.instance_id)
self.assertEqual(2, len(status.system_events))
self.assertEqual("e-event1", status.system_events[0].event_id)
self.assertEqual("SystemMaintenance.Reboot",
status.system_events[0].get_event_type())
def test_client_file(self):
config_file = ('[default]\n'
'region_id = us-west-1\n'
'endpoint = somewhere.you.will.never.get\n'
'max_retry_times = 2\n'
'http_port = 8080\n'
'https_port = 8081\n'
'connection_timeout = 2\n'
'read_timeout = 5\n')
self.write_config(config_file)
client = get_client('ecs',
access_key_id=self.access_key_id,
access_key_secret=self.access_key_secret,
region_id='hangzhou',
endpoint='123')
self.assertEqual(client.config.region_id, 'hangzhou')
self.assertEqual(client.config.endpoint, '123')
self.assertEqual(client.config.max_retry_times, '2')
self.assertEqual(client.config.http_port, '8080')
self.assertEqual(client.config.https_port, '8081')
self.assertEqual(client.config.connection_timeout, '2')
self.assertEqual(client.config.read_timeout, '5')
os.environ.pop('ALIBABA_CLOUD_CONFIG_FILE')
def test_file_ram_role_arn(self):
credentials_file = ('[default]\n'
'type = ram_role_arn\n'
'access_key_id = %s\n'
'access_key_secret = %s\n'
'role_arn = %s\n'
'role_session_name = alice\n') % (
self.access_key_id, self.access_key_secret,
self.ram_role_arn)
self.write_config(credentials_file)
client = get_client('ecs', region_id='cn-hangzhou')
try:
client.describe_regions()
assert False
except ServerException as e:
self.assertEqual(e.error_code, 'NoPermission')
self.assertEqual(e.http_status, 403)
self.assertEqual(e.endpoint, 'sts.aliyuncs.com')
self.assertEqual(
e.error_message,
'You are not authorized to do this action. You should be authorized by RAM.'
)
