def test_list_with_meta(self):
resp = fakes.create_response()
obj = resource.ListWithMeta([], resp)
self.assertEqual([], obj)
# Check request_ids attribute is added to obj
self.assertTrue(hasattr(obj, 'request_id'))
self.assertEqual(fakes.FAKE_REQUEST_ID, obj.request_id)
def test_list_quota_of_group(self, mocked):
_quotas = [
{
"type": "scaling_Policy",
"used": 2,
"quota": 50,
"max": 50
},
{
"type": "scaling_Instance",
"used": 0,
"quota": 200,
"max": 1000
}
]
quotas = [resource.AutoScalingQuota(None, q) for q in _quotas]
mocked.return_value = br.ListWithMeta(quotas, "Request-ID")
args = self.check_parser(
self.cmd,
["--group", "group-name"],
(("group", "group-name"),)
)
with self.mocked_group_find as mocked_gf:
columns, data = self.cmd.take_action(args)
mocked_gf.assert_called_once_with("group-name")
mocked.assert_called_once_with("/quotas/" + self._group.id,
key="quotas.resources")
self.assertEquals(resource.AutoScalingQuota.list_column_names,
columns)
expected = [('scaling_Policy', 50, 2, 50,),
('scaling_Instance', 200, 0, 1000,), ]
self.assertEquals(expected, data)
def test_list_policy(self, mock_list):
args = [
"--group", "group-name",
"--name", "policy-name",
"--type", "ALARM",
"--offset", "10",
"--limit", "20",
]
verify_args = [
("group", "group-name"),
("name", "policy-name"),
("type", "ALARM"),
("offset", 10),
("limit", 20),
]
args = self.check_parser(self.cmd, args, verify_args)
with self.mocked_group_find as find_group:
policies = [resource.AutoScalingPolicy(None, c)
for c in self._policies]
mock_list.return_value = br.ListWithMeta(policies, "Request-ID")
columns, data = self.cmd.take_action(args)
url = "/scaling_policy/%s/list" % self._group.id
params = {
"scaling_policy_name": "policy-name",
"scaling_policy_type": "ALARM",
"start_number": 10,
"limit": 20,
}
mock_list.assert_called_once_with(url, params=params,
key="scaling_policies")
self.assertEquals(resource.AutoScalingPolicy.list_column_names,
columns)
expected = [('67174f3d-0a7a-4c13-a890-edbe11b45242',
'as-policy-rpdj',
'ALARM',
900,
'ADD 1',
'INSERVICE'),
('81c5051a-cb1d-4993-b036-3d3afc6c9648',
'as-policy-tfum',
'SCHEDULED',
900,
'ADD 4',
'PAUSED'),
('c8e2c794-f8ef-428a-8efe-3ff1268f6804',
'WooTest',
'SCHEDULED',
900,
'ADD 1',
'INSERVICE')]
self.assertEquals(expected, data)
def test_find_config_with_name(self, mocked_get, mock_list):
configs = self.app.client_manager.auto_scaling.configs
mocked_get.side_effect = exceptions.ClientException(0)
_list = [resource.AutoScalingConfig(None, c) for c in self._configs]
mock_list.return_value = br.ListWithMeta(_list, None)
find = configs.find("config_name_1")
params = dict(scaling_configuration_name="config_name_1")
mock_list.assert_called_once_with("/scaling_configuration",
key="scaling_configurations",
params=params)
self.assertEquals(_list[0], find)
def test_list_as_log(self, mocked):
args = [
"--group",
"group-id",
"--lifecycle-status",
"INSERVICE",
"--health-status",
"NORMAL",
"--offset",
"10",
"--limit",
"20",
]
verify_args = [
("group", "group-id"),
("lifecycle_status", "INSERVICE"),
("health_status", "NORMAL"),
("offset", 10),
("limit", 20),
]
parsed_args = self.check_parser(self.cmd, args, verify_args)
with self.mocked_group_find as mocked_fg:
instances = [
resource.AutoScalingInstance(None, i) for i in self._instances
]
mocked.return_value = br.ListWithMeta(instances, "Request-ID")
columns, data = self.cmd.take_action(parsed_args)
mocked_fg.assert_called_once_with("group-id")
url = "/scaling_group_instance/%s/list" % self._group.id
params = {
"life_cycle_status": "INSERVICE",
"health_status": "NORMAL",
"start_number": 10,
"limit": 20,
}
mocked.assert_called_once_with(url,
params=params,
key="scaling_group_instances")
self.assertEquals(resource.AutoScalingInstance.list_column_names,
columns)
expected = [('dacd968b-2602-470d-a0e2-92a20c2f2b8b',
'as-config-TEO_XQF2JJSI', 'as-group-teo',
'as-config-TEO', 'INSERVICE', 'NORMAL'),
('4699d02c-6f4b-47e3-be79-8b92c665310b',
'as-config-TEO_LV1JS5P3', 'as-group-teo',
'as-config-TEO', 'INSERVICE', 'NORMAL'),
('35d9225d-ca47-4d55-bc5d-3858c34610a5',
'as-config-TEO_2MKT59WO', 'as-group-teo',
'as-config-TEO', 'INSERVICE', 'NORMAL')]
self.assertEquals(expected, data)
def test_find_group_with_name(self, mocked_get, mock_list):
groups = self.app.client_manager.auto_scaling.groups
mocked_get.side_effect = exceptions.ClientException(0)
_list = [resource.AutoScalingGroup(None, g) for g in self._groups]
mock_list.return_value = br.ListWithMeta(_list, None)
find = groups.find("Woo-Test-1")
params = dict(scaling_group_name="Woo-Test-1")
mock_list.assert_called_once_with("/scaling_group",
key="scaling_groups",
params=params)
self.assertEquals(_list[0], find)
def test_list_group(self, mock_list):
args = [
"--name",
"group-name",
"--config",
"config-1",
"--status",
"INSERVICE",
"--offset",
"10",
"--limit",
"20",
]
verify_args = [
("name", "group-name"),
("config", "config-1"),
("status", "INSERVICE"),
("offset", 10),
("limit", 20),
]
args = self.check_parser(self.cmd, args, verify_args)
with self.mocked_config_find as find_config:
groups = [resource.AutoScalingGroup(None, c) for c in self._groups]
mock_list.return_value = br.ListWithMeta(groups, "Request-ID")
columns, data = self.cmd.take_action(args)
params = {
'scaling_group_status': 'INSERVICE',
'scaling_group_name': 'group-name',
'scaling_configuration_id': self._config.id,
'limit': 20,
'start_number': 10
}
mock_list.assert_called_once_with("/scaling_group",
params=params,
key="scaling_groups")
self.assertEquals(resource.AutoScalingGroup.list_column_names,
columns)
expected = [
('f5da912c-4525-4edf-b418-cc1c8e077298', 'Woo-Test-1',
'0/1/1/3', '498c242b-54a4-48ec-afcd-bc21dd612b57', 'PAUSED'),
('ac8acbb4-e6ce-4890-a9f2-d8712b3d7385', 'as-group-teo',
'2/2/0/4', '498c242b-54a4-48ec-afcd-bc21dd612b57',
'INSERVICE'),
('56e25174-c317-4be1-9fbd-17d5aff10ad5',
'as-group-lorc-Romania1', '0/2/1/4', None, 'PAUSED')
]
self.assertEquals(expected, data)
def test_list_as_log(self, mocked):
args = [
"--group",
"group-id",
"--start-time",
"2017-02-20T00:00:00",
"--end-time",
"2017-02-22T00:00:00",
"--offset",
"10",
"--limit",
"20",
]
verify_args = [
("group", "group-id"),
("start_time", datetime.datetime(2017, 2, 20)),
("end_time", datetime.datetime(2017, 2, 22)),
("offset", 10),
("limit", 20),
]
parsed_args = self.check_parser(self.cmd, args, verify_args)
with self.mocked_group_find as mocked_fg:
logs = [resource.AutoScalingLog(None, log) for log in self.logs]
mocked.return_value = br.ListWithMeta(logs, "Request-ID")
columns, data = self.cmd.take_action(parsed_args)
mocked_fg.assert_called_once_with("group-id")
url = "/scaling_activity_log/" + self._group.id
params = {
"start_time": "2017-02-20T00:00:00Z",
"end_time": "2017-02-22T00:00:00Z",
"offset": 10,
"limit": 20,
}
mocked.assert_called_once_with(url,
params=params,
key="scaling_activity_log")
self.assertEquals(resource.AutoScalingLog.list_column_names,
columns)
expected = [
('2017-02-19T13:52:32Z', '2017-02-19T14:03:31Z', '2/3/1',
"change_reason='SCHEDULED', change_time='2017-02-19T13:41:04Z'"
", new_value='3', old_value='2'", 'SUCCESS'),
('2017-02-19T13:40:12Z', '2017-02-19T13:52:21Z', '1/2/1',
"change_reason='SCHEDULED', change_time='2017-02-19T13:40:00Z'"
", new_value='2', old_value='1'", 'SUCCESS')
]
self.assertEquals(expected, data)
def test_delete_config(self, mock_create, mock_find):
args = ["config-name-1", "config-name-2"]
verify_args = [
("config", ["config-name-1", "config-name-2"]),
]
args = self.check_parser(self.cmd, args, verify_args)
configs = [resource.AutoScalingConfig(None, c) for c in self._configs]
mock_find.side_effect = br.ListWithMeta(configs, "request-id")
result = self.cmd.take_action(args)
json = {
"scaling_configuration_id": [c.id for c in configs]
}
mock_create.assert_called_once_with("/scaling_configurations",
json=json,
raw=True, )
self.assertEquals('done', result)
def mixin_meta(item, resp):
if isinstance(item, six.string_types):
if six.PY2 and isinstance(item, six.text_type):
return resource.UnicodeWithMeta(item, resp)
else:
return resource.StrWithMeta(item, resp)
elif isinstance(item, six.binary_type):
return resource.BytesWithMeta(item, resp)
elif isinstance(item, list):
return resource.ListWithMeta(item, resp)
elif isinstance(item, tuple):
return resource.TupleWithMeta(item, resp)
elif item is None:
return resource.TupleWithMeta((), resp)
else:
return resource.DictWithMeta(item, resp)
def test_list_configs(self, mock_list, mock_util):
args = [
"--name",
"config-name",
"--image",
"image-name",
"--offset",
"10",
"--limit",
"20",
]
verify_args = [
("name", "config-name"),
("image", "image-name"),
("offset", 10),
("limit", 20),
]
args = self.check_parser(self.cmd, args, verify_args)
configs = [resource.AutoScalingConfig(None, c) for c in self._configs]
mock_list.return_value = br.ListWithMeta(configs, "Request-ID")
mock_util.return_value = br.Resource(None, dict(id="image-id"))
columns, data = self.cmd.take_action(args)
mock_util.assert_called_once_with(self.app.client_manager.image.images,
"image-name")
params = {
"scaling_configuration_name": "config-name",
"image_id": "image-id",
"start_number": 10,
"limit": 20,
}
mock_list.assert_called_once_with("/scaling_configuration",
key="scaling_configurations",
params=params)
self.assertEquals(resource.AutoScalingConfig.list_column_names,
columns)
expected = [
('6afe46f9-7d3d-4046-8748-3b2a1085ad86', 'config_name_1',
'37ca2b35-6fc7-47ab-93c7-900324809c5c', '2015-07-23T01:04:07Z'),
('24a8c5f3-c713-4aba-ac29-c17101009e5d', 'config_name_2',
'37ca2b35-6fc7-47ab-93c7-900324809c5c', '2015-07-22T01:08:41Z')
]
self.assertEquals(expected, data)
def test_remove_as_instance(self, mock_create, mock_list):
args = [
"--group",
"group-id",
"--instance",
"dacd968b-2602-470d-a0e2-92a20c2f2b8b",
"--instance",
"as-config-TEO_2MKT59WO",
"--delete",
]
verify_args = [
("group", "group-id"),
("instances", [
"dacd968b-2602-470d-a0e2-92a20c2f2b8b",
"as-config-TEO_2MKT59WO",
]),
("delete", True),
]
parsed_args = self.check_parser(self.cmd, args, verify_args)
with self.mocked_group_find as mocked_fg:
instances = [
resource.AutoScalingInstance(None, i) for i in self._instances
]
mock_list.return_value = br.ListWithMeta(instances, "Request-ID")
mock_create.return_value = br.StrWithMeta('', 'Request-ID-2')
result = self.cmd.take_action(parsed_args)
mocked_fg.assert_called_once_with("group-id")
mock_list.assert_called_once_with(self._group.id)
url = "/scaling_group_instance/%s/action" % self._group.id
json = {
"action":
"REMOVE",
"instances_id": [
"dacd968b-2602-470d-a0e2-92a20c2f2b8b",
"35d9225d-ca47-4d55-bc5d-3858c34610a5",
],
"instance_delete":
"yes"
}
mock_create.assert_called_once_with(url, json=json, raw=True)
self.assertEquals('done', result)
def _list(self, url, params={}, resource_class=None, key=None, headers={}):
""" common list resource function
:rtype: Resource
"""
resp, body = self.http_client.get(url, params=params, headers=headers)
resource_class = (resource_class
if resource_class else self.resource_class)
# get required body part
data = self.get_data(body, key)
data = data if data else []
if all([isinstance(_resource, six.string_types)
for _resource in data]):
items = data
else:
items = [
resource_class(self, _resource, attached=True, resp=resp)
for _resource in data if _resource
]
return resource.ListWithMeta(items, resp)
def test_find_config_with_name_no_match(self, mocked_get, mock_list):
configs = self.app.client_manager.auto_scaling.configs
mocked_get.side_effect = exceptions.ClientException(0)
mock_list.return_value = br.ListWithMeta([], None)
self.assertRaises(exceptions.NotFound, configs.find, "config_name_1")
