def test_resolver_with_jsonstr(self):
resolver = LocalConfigRegionalEndpointResolver("{}")
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(
resolver._make_endpoint_entry_key("ecs", "cn-huhehaote"),
"ecs.cn-huhehaote")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertTrue(resolver.is_region_id_valid(request))
resolver.put_endpoint_entry("ecs.cn-huhehaote",
"my-endpoint-for-cnhuhehaote-ecs")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
"my-endpoint-for-cnhuhehaote-ecs")
self.assertTrue(resolver.is_region_id_valid(request))
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "innerAPI")
self.assertEqual(resolver.resolve(request), None)
# _get_normalized_product_code
self.assertEqual(resolver._get_normalized_product_code("cloudapi"),
"cloudapi")
self.assertEqual(resolver._get_normalized_product_code("ecs"), "ecs")
def test_resolver(self):
resolver = LocalConfigRegionalEndpointResolver()
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(
resolver._make_endpoint_entry_key("ecs", "cn-huhehaote"),
"ecs.cn-huhehaote")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
'ecs.cn-huhehaote.aliyuncs.com')
self.assertTrue(resolver.is_region_id_valid(request))
# resolver.put_endpoint_entry("ecs", "my-endpoint-for-cnhuhehaote-ecs")
# request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
# self.assertEqual(resolver.resolve(request), "my-endpoint-for-cnhuhehaote-ecs")
# self.assertTrue(resolver.is_region_id_valid(request))
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "innerAPI")
self.assertEqual(resolver.resolve(request), None)
# _get_normalized_product_code
self.assertEqual(resolver._get_normalized_product_code("cloudapi"),
"apigateway")
self.assertEqual(resolver._get_normalized_product_code("ecs"), "ecs")
self.assertListEqual(resolver.get_valid_region_ids_by_product('ecs'), [
'ap-northeast-1', 'ap-south-1', 'ap-southeast-2', 'ap-southeast-3',
'ap-southeast-5', 'cn-huhehaote', 'cn-zhangjiakou', 'eu-central-1',
'me-east-1'
])
self.assertIsNone(resolver.get_valid_region_ids_by_product('xxx'))
self.assertTrue(resolver.is_product_code_valid(request))
def test_resolver(self):
resolver = LocalConfigRegionalEndpointResolver()
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(
resolver._make_endpoint_entry_key("ecs", "cn-huhehaote"),
"ecs.cn-huhehaote")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
'ecs.cn-huhehaote.aliyuncs.com')
self.assertTrue(resolver.is_region_id_valid(request))
# resolver.put_endpoint_entry("ecs", "my-endpoint-for-cnhuhehaote-ecs")
# request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
# self.assertEqual(resolver.resolve(request), "my-endpoint-for-cnhuhehaote-ecs")
# self.assertTrue(resolver.is_region_id_valid(request))
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "innerAPI")
self.assertEqual(resolver.resolve(request), None)
# _get_normalized_product_code
self.assertEqual(resolver._get_normalized_product_code("cloudapi"),
"apigateway")
self.assertEqual(resolver._get_normalized_product_code("ecs"), "ecs")
self.assertEqual(len(resolver.get_valid_region_ids_by_product('ecs')),
19)
self.assertIsNone(resolver.get_valid_region_ids_by_product('xxx'))
self.assertTrue(resolver.is_product_code_valid(request))
def test_resolver_has_endpoint(self):
resolver = EndpointResolverRules(None)
request = ResolveEndpointRequest("cn-hangzhou", "product_code", "", "")
endpoint_data = EndpointData()
request.endpoint_map = endpoint_data.endpoint_map
request.endpoint_regional = endpoint_data.endpoint_regional
endpoint = resolver.resolve(request)
self.assertEqual("mock.endpoint", endpoint)
def test_resolver_reginoal(self):
resolver = EndpointResolverRules(None)
endpoint_data = EndpointData()
request = ResolveEndpointRequest("cn-beijing", "test", "", "")
request.endpoint_map = endpoint_data.endpoint_map
request.endpoint_regional = endpoint_data.endpoint_regional
endpoint = resolver.resolve(request)
self.assertEqual("test.cn-beijing.aliyuncs.com", endpoint)
def test_is_product_code_valid(self):
resolver = LocationServiceEndpointResolver(None)
request = ResolveEndpointRequest("region_id", "product", "", "")
self.assertFalse(resolver.is_product_code_valid(request))
resolver._invalid_product_codes.add("invalid_product")
request = ResolveEndpointRequest("region_id", "invalid_product",
"servicecode", "")
self.assertFalse(resolver.is_product_code_valid(request))
def test_resolver_network_special_endpoint(self):
resolver = EndpointResolverRules(None)
endpoint_data = EndpointData()
resolver.endpoint_map = endpoint_data.endpoint_map
resolver.endpoint_regional = endpoint_data.endpoint_regional
request = ResolveEndpointRequest("foo", "test", "", "")
request.request_network = "vpc"
endpoint = resolver.resolve(request)
self.assertEqual("test-vpc.foo.aliyuncs.com", endpoint)
def test_resolver_with_jsonstr(self):
resolver = LocalConfigGlobalEndpointResolver("{}")
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(resolver._make_endpoint_entry_key("ram"), "ram")
request = ResolveEndpointRequest("cn-huhehaote", "ram", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertTrue(resolver.is_region_id_valid(request))
request = ResolveEndpointRequest("cn-huhehaote", "ram", "", "innerAPI")
self.assertEqual(resolver.resolve(request), None)
def test_request(self):
r = ResolveEndpointRequest("cn-hangzhou", "product_code",
"location_service_code", "innerAPI")
self.assertFalse(r.is_open_api_endpoint())
r = ResolveEndpointRequest("cn-hangzhou", "product_code",
"location_service_code", "openAPI")
self.assertTrue(r.is_open_api_endpoint())
r = ResolveEndpointRequest("cn-hangzhou", "product_code",
"location_service_code", None)
self.assertTrue(r.is_open_api_endpoint())
def test_resolver_with_server_exception_invalid_regionid(self):
client = Mock()
client.do_action_with_exception.side_effect = ServerException(
"InvalidRegionId", "The specified region does not exist.")
resolver = LocationServiceEndpointResolver(client)
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
self.assertEqual(resolver.resolve(request), None)
client.do_action_with_exception.side_effect = ServerException(
"Illegal Parameter", "Please check the parameters")
resolver = LocationServiceEndpointResolver(client)
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
self.assertEqual(resolver.resolve(request), None)
def test_resolver(self):
resolver = LocalConfigGlobalEndpointResolver()
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(resolver._make_endpoint_entry_key("ram"), "ram")
request = ResolveEndpointRequest("cn-huhehaote", "ram", "", "")
self.assertEqual(resolver.resolve(request), 'ram.aliyuncs.com')
self.assertTrue(resolver.is_region_id_valid(request))
request = ResolveEndpointRequest("cn-huhehaote", "ram", "", "innerAPI")
self.assertEqual(resolver.resolve(request), None)
# _get_normalized_product_code
self.assertEqual(resolver._get_normalized_product_code("cloudapi"),
"apigateway")
self.assertEqual(resolver._get_normalized_product_code("ram"), "ram")
def test_resolver(self):
# clinet = Mock()
resolver = DefaultEndpointResolver(None)
# can not be resolved
request = ResolveEndpointRequest("mars", "ecs", "", "")
request.product_suffix = 'api'
with self.assertRaises(ClientException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "SDK.EndpointResolvingError")
self.assertEqual(
ex.exception.message,
"No such region 'mars'. Please check your region ID.")
resolver.put_endpoint_entry("mars", "ecs", "mars-endpoint-for-ecs")
self.assertEqual(resolver.resolve(request), "mars-endpoint-for-ecs")
def test_resolver(self):
# clinet = Mock()
resolver = EndpointResolverRules(None)
# can not be resolved
request = ResolveEndpointRequest("region_id", "product_code", "", "")
endpoint = resolver.resolve(request)
self.assertEqual(None, endpoint)
def test_resolver(self):
# clinet = Mock()
resolver = EndpointResolverRules(None)
# can not be resolved
request = ResolveEndpointRequest("foo", "test", "", "")
endpoint = resolver.resolve(request)
self.assertEqual(None, endpoint)
def test_resolver(self):
resolver = UserCustomizedEndpointResolver()
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertEqual(resolver._make_endpoint_entry_key(
"ecs", "cn-huhehaote"), "ecs.cn-huhehaote")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request), None)
self.assertFalse(resolver.is_region_id_valid("cn-huhehaote"))
resolver.put_endpoint_entry(
"cn-huhehaote", "ecs", "my-endpoint-for-cnhuhehaote-ecs")
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
"my-endpoint-for-cnhuhehaote-ecs")
self.assertTrue(resolver.is_region_id_valid("cn-huhehaote"))
resolver.reset()
self.assertEqual(resolver.resolve(request), None)
def _resolve_endpoint(self, request):
resolve_request = ResolveEndpointRequest(
self._region_id,
request.get_product(),
request.get_location_service_code(),
request.get_location_endpoint_type(),
)
return self._endpoint_resolver.resolve(resolve_request)
def resolve(self,
region_id,
product_code,
location_service_code=None,
endpoint_type=None):
request = ResolveEndpointRequest(region_id, product_code,
location_service_code, endpoint_type)
return self._endpoint_resolver.resolve(request)
def test_resolver_has_endpoint(self):
resolver = EndpointResolverRules(None)
request = ResolveEndpointRequest("foo", "test", "", "")
endpoint_data = EndpointData()
resolver.endpoint_map = endpoint_data.endpoint_map
resolver.endpoint_regional = endpoint_data.endpoint_regional
endpoint = resolver.resolve(request)
self.assertEqual("bar", endpoint)
def test_resolver_central(self):
resolver = EndpointResolverRules(None)
endpoint_data = EndpointData()
endpoint_data.endpoint_regional = "central"
resolver.endpoint_map = endpoint_data.endpoint_map
resolver.endpoint_regional = endpoint_data.endpoint_regional
request = ResolveEndpointRequest("cn-hangzhou", "test", "", "")
endpoint = resolver.resolve(request)
self.assertEqual("test.aliyuncs.com", endpoint)
def test_resolver_with_location(self):
client = Mock()
client.do_action_with_exception.return_value = ensure_bytes(
'{"Code": "Success","Endpoints": {"Endpoint": []}}')
resolver = LocationServiceEndpointResolver(client)
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
self.assertEqual(resolver.resolve(request), None)
def is_product_code_valid(self, request):
tmp_request = ResolveEndpointRequest(
request.region_id,
self._get_normalized_product_code(request.product_code),
request.location_service_code,
request.endpoint_type,
)
return EndpointResolverBase.is_product_code_valid(self, tmp_request)
def test_resolver(self):
user = UserCustomizedEndpointResolver()
chain = [user]
resolver = ChainedEndpointResolver(chain)
# can not be resolved
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
with self.assertRaises(ClientException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "SDK.EndpointResolvingError")
self.assertEqual(
ex.exception.message, "No endpoint for product 'ecs'. \n"
"Please check the product code, or set an endpoint for your request explicitly.\n"
"See https://www.alibabacloud.com/help/doc-detail/92074.htm\n")
user.put_endpoint_entry("cn-huhehaote", "ecs",
"my-endpoint-for-cnhuhehaote-ecs")
# can be resolved
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
"my-endpoint-for-cnhuhehaote-ecs")
def test_resolver_with_location2(self):
client = Mock()
client.do_action_with_exception.return_value = ensure_bytes(
'{"Code": "Success","Endpoints": {"Endpoint": [{"ServiceCode":"servicecode",'
+
'"Type":"innerAPI","Endpoint":"the inner endpoint"},{"ServiceCode":"servicecode",'
+ '"Type":"openAPI","Endpoint":"the endpoint"}]}}')
resolver = LocationServiceEndpointResolver(client)
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
self.assertEqual(resolver.resolve(request), "the endpoint")
def test_resolver_with_server_exception(self):
client = Mock()
client.do_action_with_exception.side_effect = ServerException(
"OTHER_ERROR_CODE", "msg")
resolver = LocationServiceEndpointResolver(client)
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
with self.assertRaises(ServerException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "OTHER_ERROR_CODE")
self.assertEqual(ex.exception.message, "msg")
def test_resolver(self):
resolver = LocationServiceEndpointResolver(None)
# no location_service_code
request = ResolveEndpointRequest("", "", "", "")
self.assertEqual(resolver.resolve(request), None)
# invalid products
resolver._invalid_product_codes.add("invalid_product")
request = ResolveEndpointRequest("cn-huhehaote", "invalid_product",
"servicecode", "")
self.assertEqual(resolver.resolve(request), None)
# invalid region id
resolver._invalid_region_ids.add("invalid_region_id")
request = ResolveEndpointRequest("invalid_region_id", "product",
"servicecode", "")
self.assertEqual(resolver.resolve(request), None)
# match cache
request = ResolveEndpointRequest("region_id", "product", "servicecode",
"")
resolver.endpoints_data[
"product.servicecode.region_id.openAPI"] = "the fake endpoint"
self.assertEqual(resolver.resolve(request), "the fake endpoint")
def _resolve_endpoint(self, request):
if self._region_id:
aliyunsdkcore.utils.validation.validate_pattern(
self._region_id, 'region_id', '^[a-zA-Z0-9_-]+$'
)
if request.product_suffix:
aliyunsdkcore.utils.validation.validate_pattern(
request.product_suffix, 'suffix', '^[a-zA-Z0-9_-]+$'
)
if request.request_network:
aliyunsdkcore.utils.validation.validate_pattern(
request.request_network, 'network', '^[a-zA-Z0-9_-]+$'
)
resolve_request = ResolveEndpointRequest(
self._region_id,
request.get_product(),
request.get_location_service_code(),
request.get_location_endpoint_type(),
)
resolve_request.request_network = request.request_network
resolve_request.product_suffix = request.product_suffix
resolve_request.endpoint_map = request.endpoint_map
resolve_request.endpoint_regional = request.endpoint_regional
return self._endpoint_resolver.resolve(resolve_request)
def test_faas_resolve(self):
resolver = DefaultEndpointResolver(self.client)
request = ResolveEndpointRequest("cn-hangzhou", "faas", None, None)
self.assertEqual("faas.cn-hangzhou.aliyuncs.com", resolver.resolve(request))
client = self.init_client(region_id="cn-hangzhou")
from aliyunsdkfaas.request.v20170824.DescribeLoadTaskStatusRequest \
import DescribeLoadTaskStatusRequest
request = DescribeLoadTaskStatusRequest()
request.set_FpgaUUID("blah")
request.set_InstanceId("blah")
request.set_RoleArn("blah")
try:
client.do_action_with_exception(request)
assert False
except ServerException as e:
self.assertNotEqual(error_code.SDK_ENDPOINT_RESOLVING_ERROR, e.get_error_code())
def _resolve_endpoint(self, request):
resolve_request = ResolveEndpointRequest(
self.__region_id,
request.get_product(),
request.get_location_service_code(),
request.get_location_endpoint_type(),
)
endpoint = self._endpoint_resolver.resolve(resolve_request)
if endpoint.endswith("endpoint-test.exception.com"):
# For endpoint testability, if the endpoint is xxxx.endpoint-test.special.com
# throw a client exception with this endpoint
raise ClientException(error_code.SDK_ENDPOINT_TESTABILITY, endpoint)
return endpoint
def test_resolver(self):
user = UserCustomizedEndpointResolver()
chain = [
user
]
resolver = ChainedEndpointResolver(chain)
# can not be resolved
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
with self.assertRaises(ClientException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "SDK.EndpointResolvingError")
self.assertEqual(ex.exception.message,
"No endpoint for product 'ecs'.\n"
"Please check the product code, or set an endpoint for your request "
"explicitly.\n"
"See https://www.alibabacloud.com/help/doc-detail/92074.htm\n")
user.put_endpoint_entry("cn-huhehaote", "ecs",
"my-endpoint-for-cnhuhehaote-ecs")
# can not be resolved with cn-hangzhou
request = ResolveEndpointRequest("cn-hangzhou", "ecs", "", "")
with self.assertRaises(ClientException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "SDK.EndpointResolvingError")
self.assertEqual(
ex.exception.message, "No endpoint in the region 'cn-hangzhou' for product 'ecs'.\n"
"You can set an endpoint for your request explicitly.\n"
"See https://www.alibabacloud.com/help/doc-detail/92074.htm\n"
)
# cn-hangzhou and ecs is valid
user.put_endpoint_entry("cn-hangzhou", "rds",
"my-endpoint-for-cn-hangzhou-rds")
with self.assertRaises(ClientException) as ex:
resolver.resolve(request)
self.assertEqual(ex.exception.error_code, "SDK.EndpointResolvingError")
self.assertEqual(
ex.exception.message, "No endpoint in the region 'cn-hangzhou' for product 'ecs'.\n"
"You can set an endpoint for your request explicitly.\n"
"See https://www.alibabacloud.com/help/doc-detail/92074.htm\n")
# can be resolved
request = ResolveEndpointRequest("cn-huhehaote", "ecs", "", "")
self.assertEqual(resolver.resolve(request),
"my-endpoint-for-cnhuhehaote-ecs")
chain = [
LocalConfigRegionalEndpointResolver(),
user
]
resolver = ChainedEndpointResolver(chain)
request.request_network = 'inner'
endpoint = resolver.resolve(request)
self.assertEqual('my-endpoint-for-cnhuhehaote-ecs', endpoint)
def resolve(self, region_id, product_code, location_service_code=None, endpoint_type=None,
request=None):
resolve_request = ResolveEndpointRequest(region_id, product_code,
location_service_code, endpoint_type)
if request:
resolve_request.request_network = request.request_network
resolve_request.product_suffix = request.product_suffix
resolve_request.endpoint_map = request.endpoint_map
resolve_request.endpoint_regional = request.endpoint_regional
return self._endpoint_resolver.resolve(resolve_request)
