def test_delete_volume(self):
response_a_json = get_response_json_by_type(DS8K_VOLUME)
response_a = get_response_data_by_type(DS8K_VOLUME)
name = self._get_resource_id_from_resopnse(DS8K_VOLUME, response_a,
Volume.id_field)
url = '/volumes/{}'.format(name)
httpretty.register_uri(
httpretty.GET,
self.domain + self.base_url + url,
body=response_a_json,
content_type='application/json',
status=200,
)
httpretty.register_uri(
httpretty.DELETE,
self.domain + self.base_url + url,
body=action_response_json,
content_type='application/json',
status=204,
)
# Way 1
_ = self.system.delete_volume(name)
self.assertEqual(httpretty.DELETE, httpretty.last_request().method)
# self.assertEqual(resp1, action_response['server'])
# Way 2
volume = self.system.get_volume(name)
self.assertIsInstance(volume, Volume)
resp2, _ = volume.delete()
self.assertEqual(resp2.status_code, 204)
self.assertEqual(httpretty.DELETE, httpretty.last_request().method)
def _test_sub_resource_post(self, route, sub_route, func, body, *params):
route_id = self._set_resource_list(route)
self._post_sub_resource(route, route_id, sub_route, body)
func = func or 'get_{}'.format(route)
res = getattr(self.rest_client, func)(route_id, *params)[0]
rep = ResponseParser(get_response_data_by_type(sub_route),
sub_route).get_representations()[0]
self._assert_equal_between_obj_and_dict(res, rep)
def _test_sub_resource(self, route, sub_route, func):
route_id = self._set_resource_list(route)
self._set_sub_resource(route, route_id, sub_route)
res = getattr(self.rest_client, func)(route_id)[0]
self.assertIsInstance(res, dict)
# print "&&&&&&&&&&&{}".format(res)
rep = ResponseParser(get_response_data_by_type(sub_route),
sub_route).get_representations()[0]
self._assert_equal_between_dicts(res, rep)
def _test_related_resource_field(self, route):
info = get_response_data_by_type(route)['data'][route][0]
res_class = self._get_class_by_name(route)
for rel, relclass_tuple in res_class.related_resource.items():
rel_class, _ = relclass_tuple
rel_id = info[rel[1:]][rel_class.id_field]
res = res_class(self.client, info=info)
self.assertEqual(getattr(res, rel[1:]), rel_id)
self.assertEqual(res.representation[rel[1:]], rel_id)
self.assertIsInstance(getattr(res, rel), rel_class)
self.assertEqual(getattr(res, rel).id, rel_id)
def _test_resource_by_route(self, route, func, sub_resource=[]):
base_route = route.split('.')[-1]
route_id = self._set_resource_list(route)
if sub_resource:
for sub_route in sub_resource:
self._set_sub_resource(route, route_id, sub_route)
res = getattr(self.rest_client, func)(route_id)[0]
self.assertIsInstance(res, dict)
rep = ResponseParser(get_response_data_by_type(base_route),
base_route).get_representations()[0]
self._assert_equal_between_dicts(res, rep)
def _test_sub_resource_list_by_route(self, route, sub_route,
cmp_func=None
):
sub_res_list_resp = get_response_list_data_by_type(sub_route)
res_resp = get_response_data_by_type(route)
res_class = self._get_class_by_name(route)
id_field = res_class.id_field
route_id = self._get_resource_id_from_resopnse(route,
res_resp,
id_field
)
route_url = '/{}/{}'.format(route, route_id)
sub_route_url = '/{}/{}/{}'.format(route, route_id, sub_route)
cmp_f = cmp_func if cmp_func else self._sorted_by_id
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + sub_route_url,
body=get_response_list_json_by_type(sub_route),
content_type='application/json',
status=200,
)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + route_url,
body=get_response_json_by_type(route),
content_type='application/json',
status=200,
)
try:
res = getattr(
self.system,
'get_{}'.format(route)
)(route_id)
except AttributeError:
if route == types.DS8K_LSS:
res = self.system.get_lss_by_id(route_id)
else:
raise Exception(
'Failed calling get_{}'.format(route)
)
self.assertIsInstance(res, res_class)
sub_res_list = getattr(res, 'get_{}'.format(sub_route))()
self.assertIs(getattr(res, sub_route), sub_res_list)
sub_res_list.sort(key=cmp_to_key(cmp_f))
sub_res_list_data = list(sub_res_list_resp['data'][sub_route])
sub_res_list_data.sort(key=cmp_to_key(cmp_f))
self.assertNotEqual(0, len(sub_res_list))
self.assertEqual(len(sub_res_list_data),
len(sub_res_list)
)
self._assert_equal_between_sorted_dict_and_resource_list(
sub_res_list_data,
sub_res_list
)
def test_update_host_field(self):
host_info = get_response_data_by_type(
DS8K_HOST_PORT)['data'][DS8K_HOST_PORT][0]
host_name = host_info['host']['name']
self.host_port._add_details(host_info)
self.assertEqual(self.host_port.host, host_name)
self.assertEqual(self.host_port.representation['host'], host_name)
self.assertIsInstance(self.host_port._host, Host)
self.assertEqual(self.host_port._host.id, host_name)
self.host_port.host = 'new_host'
self.assertEqual(self.host_port.host, 'new_host')
self.assertEqual(self.host_port.representation['host'], 'new_host')
def test_occupied_ioports(self):
OCCUPIED_IOPORTS = 'login_ports'
info = get_response_data_by_type(
DS8K_HOST_PORT)['data'][DS8K_HOST_PORT][0]
host_port = HostPort(self.client,
HostPortManager(self.client),
info=info)
ioport_ids = [
port.get(IOPort.id_field) for port in info[OCCUPIED_IOPORTS]
]
self.assertCountEqual(ioport_ids,
host_port.representation.get(OCCUPIED_IOPORTS))
self.assertIsInstance(getattr(host_port, OCCUPIED_IOPORTS)[0], IOPort)
self.assertIn(getattr(host_port, OCCUPIED_IOPORTS)[0].id, ioport_ids)
def test_update_host_add_ioports(self):
response_a_json = get_response_json_by_type(DS8K_HOST)
response_a = get_response_data_by_type(DS8K_HOST)
host_name = self._get_resource_id_from_resopnse(DS8K_HOST, response_a,
Host.id_field
)
res_all = get_response_list_data_by_type(DS8K_IOPORT)
ioport_ids = self._get_resource_ids_from_resopnse(DS8K_IOPORT, res_all,
IOPort.id_field
)
port_id = 'new_port_id'
url = '/hosts/{}'.format(host_name)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + url,
body=response_a_json,
content_type='application/json',
status=200,
)
def _verify_request(request, uri, headers):
self.assertEqual(uri, self.domain + self.base_url + url)
ioport_ids.append(port_id)
resq = RequestParser({'ioports': ioport_ids})
self.assertEqual(json.loads(request.body), resq.get_request_data())
return (200, headers, action_response_json)
httpretty.register_uri(httpretty.PUT,
self.domain + self.base_url + url,
body=_verify_request,
content_type='application/json',
)
ioport_url = '{}/{}'.format(url, DS8K_IOPORT)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + ioport_url,
body=get_response_list_json_by_type(
DS8K_IOPORT),
content_type='application/json',
status=200,
)
host = self.system.get_host(host_name)
resp = host.update_host_add_ioports(port_id)
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(resp, action_response['server'])
def test_lazy_loading_related_resources_collection(self):
response_a_json = get_response_json_by_type(DS8K_HOST)
response_a = get_response_data_by_type(DS8K_HOST)
host_name = self._get_resource_id_from_resopnse(DS8K_HOST, response_a,
Host.id_field
)
url = '/hosts/{}'.format(host_name)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + url,
body=response_a_json,
content_type='application/json',
status=200,
)
for item in Host.related_resources_collection:
sub_route_url = '{}/{}'.format(url, item)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + sub_route_url,
body=get_response_list_json_by_type(item),
content_type='application/json',
status=200,
)
host = self.system.get_host(host_name)
for item in Host.related_resources_collection:
res_collection = getattr(host, item)
self.assertNotEqual(0, len(res_collection))
res_collection.sort(
key=cmp_to_key(
self._get_sort_func_by(res_collection[0].id_field))
)
res_collection_data = list(
get_response_list_data_by_type(item)['data'][item]
)
res_collection_data.sort(
key=cmp_to_key(
self._get_sort_func_by(res_collection[0].id_field))
)
self.assertEqual(
len(res_collection_data),
len(res_collection))
self._assert_equal_between_sorted_dict_and_resource_list(
res_collection_data,
res_collection
)
def test_related_resource_field(self):
pprc_info = get_response_data_by_type(DS8K_PPRC)['data'][DS8K_PPRC][0]
sourcevolume_id = pprc_info['sourcevolume'][Volume.id_field]
targetvolume_id = pprc_info['targetvolume'][Volume.id_field]
targetsystem_id = pprc_info['targetsystem'][System.id_field]
pprc = PPRC(self.client, info=pprc_info)
self.assertEqual(pprc.sourcevolume, sourcevolume_id)
self.assertEqual(pprc.representation['sourcevolume'], sourcevolume_id)
self.assertIsInstance(pprc._sourcevolume, Volume)
self.assertEqual(pprc._sourcevolume.id, sourcevolume_id)
self.assertEqual(pprc.targetvolume, targetvolume_id)
self.assertEqual(pprc.representation['targetvolume'], targetvolume_id)
self.assertIsInstance(pprc._targetvolume, Volume)
self.assertEqual(pprc._targetvolume.id, targetvolume_id)
self.assertEqual(pprc.targetsystem, targetsystem_id)
self.assertEqual(pprc.representation['targetsystem'], targetsystem_id)
self.assertIsInstance(pprc._targetsystem, System)
self.assertEqual(pprc._targetsystem.id, targetsystem_id)
def _test_resource_by_route(self, route):
resource_response = get_response_data_by_type(route)
res_class = self._get_class_by_name(route)
id_field = res_class.id_field
route_id = self._get_resource_id_from_resopnse(route,
resource_response,
id_field)
url = '/{}/{}'.format(route, route_id)
httpretty.register_uri(
httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(route),
content_type='application/json',
status=200,
)
res = getattr(self.system, 'get_{}'.format(route))(route_id)
self.assertIsInstance(res, res_class)
res_data = resource_response['data'][route][0]
self._assert_equal_between_dict_and_resource(res_data, res)
def test_related_resource_field(self):
volume_info = get_response_data_by_type(
DS8K_VOLUME)['data'][DS8K_VOLUME][0]
pool_id = volume_info['pool'][Pool.id_field]
lss_id = volume_info['lss']['id']
volume = Volume(self.client, info=volume_info)
self.assertEqual(volume.pool, pool_id)
self.assertEqual(volume.representation['pool'], pool_id)
self.assertIsInstance(volume._pool, Pool)
self.assertEqual(volume._pool.id, pool_id)
self.assertEqual(volume.lss, lss_id)
self.assertEqual(volume.representation['lss'], lss_id)
self.assertIsInstance(volume._lss, LSS)
self.assertEqual(volume._lss.id, lss_id)
volume.pool = 'new_pool'
self.assertEqual(volume.pool, 'new_pool')
self.assertEqual(volume.representation['pool'], 'new_pool')
with self.assertRaises(FieldReadOnly):
volume.lss = 'new_lss'
def _set_resource_list(self, route):
base_route = route.split('.')[-1]
resource_response = get_response_data_by_type(base_route)
prefix = '{}.{}'.format(self.client.service_type,
self.client.service_version)
res_class, _ = get_resource_and_manager_class_by_route("{}.{}".format(
prefix,
str(route).lower()))
if res_class.__name__ == Resource.__name__:
raise Exception(
'Can not get resource class from route: {}'.format(route))
id_field = res_class.id_field
route_id = self._get_resource_id_from_resopnse(base_route,
resource_response,
id_field)
url = '/{}/{}'.format(route.replace('.', '/'), route_id)
httpretty.register_uri(
httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(base_route),
content_type='application/json',
status=200,
)
return route_id
from pyds8k.resources.ds8k.v1.common.types import DS8K_POOL, \
DS8K_VOLUME, \
DS8K_TSEREP, \
DS8K_ESEREP
from pyds8k.test.data import get_response_list_json_by_type, \
get_response_list_data_by_type, \
get_response_json_by_type, \
get_response_data_by_type
from pyds8k.test.data import action_response, action_response_json
from .base import TestDS8KWithConnect
from pyds8k.resources.ds8k.v1.volumes import Volume
from pyds8k.resources.ds8k.v1.pools import Pool
from pyds8k.resources.ds8k.v1.tserep import TSERep
from pyds8k.resources.ds8k.v1.eserep import ESERep
response_a = get_response_data_by_type(DS8K_POOL)
response_a_json = get_response_json_by_type(DS8K_POOL)
class TestPool(TestDS8KWithConnect):
def setUp(self):
super(TestPool, self).setUp()
self.pool_id = self._get_resource_id_from_resopnse(
DS8K_POOL, response_a, Pool.id_field)
self.pool = self.system.one(DS8K_POOL, self.pool_id, rebuild_url=True)
def test_get_volumes(self):
self._test_sub_resource_list_by_route(DS8K_POOL, DS8K_VOLUME,
self._sorted_by_volume_name)
def test_get_tserep(self):
from pyds8k.exceptions import InternalServerError, FieldReadOnly
from pyds8k.messages import DEFAULT_SUCCESS_BODY_DICT
from pyds8k.resources.ds8k.v1.common.types import DS8K_HOST_PORT
from pyds8k.resources.ds8k.v1.host_ports import HostPort, \
HostPortManager
from pyds8k.resources.ds8k.v1.ioports import IOPort
from pyds8k.resources.ds8k.v1.hosts import Host
from .base import TestDS8KWithConnect
from pyds8k.test.data import get_response_json_by_type, \
get_response_data_by_type
from pyds8k.test.data import action_response, action_response_json, \
action_response_failed, action_response_failed_json, \
create_host_port_response_json
from pyds8k.dataParser.ds8k import RequestParser
response_a = get_response_data_by_type(DS8K_HOST_PORT)
response_a_json = get_response_json_by_type(DS8K_HOST_PORT)
class TestHostPort(TestDS8KWithConnect):
def setUp(self):
super(TestHostPort, self).setUp()
self.host_port = HostPort(self.client, HostPortManager(self.client))
self.wwpn = self._get_resource_id_from_resopnse(
DS8K_HOST_PORT, response_a, HostPort.id_field)
@httpretty.activate
def test_delete_host_port(self):
url = '/host_ports/{}'.format(self.wwpn)
httpretty.register_uri(
httpretty.GET,
get_response_data_by_type, \
get_response_json_by_type
from pyds8k.test.data import action_response_json
from .base import TestDS8KWithConnect
from pyds8k.resources.ds8k.v1.systems import System
from pyds8k.resources.ds8k.v1.lss import LSS
# from pyds8k.resources.ds8k.v1.ioports import IOPort
from pyds8k.resources.ds8k.v1.tserep import TSERep
from pyds8k.resources.ds8k.v1.eserep import ESERep
from pyds8k.resources.ds8k.v1.volumes import Volume
system_list_response = get_response_list_data_by_type(types.DS8K_SYSTEM)
system_list_response_json = get_response_list_json_by_type(types.DS8K_SYSTEM)
lss_list_response = get_response_list_data_by_type(types.DS8K_LSS)
lss_list_response_json = get_response_list_json_by_type(types.DS8K_LSS)
lss_a_response = get_response_data_by_type(types.DS8K_LSS)
lss_a_response_json = get_response_json_by_type(types.DS8K_LSS)
ioport_list_response = get_response_list_data_by_type(types.DS8K_IOPORT)
ioport_list_response_json = get_response_list_json_by_type(types.DS8K_IOPORT)
ioport_a_response = get_response_data_by_type(types.DS8K_IOPORT)
ioport_a_response_json = get_response_json_by_type(types.DS8K_IOPORT)
tserep_list_response_json = get_response_list_json_by_type(types.DS8K_TSEREP)
eserep_list_response_json = get_response_list_json_by_type(types.DS8K_ESEREP)
volume_list_response = get_response_list_data_by_type(types.DS8K_VOLUME)
volume_list_response_json = get_response_list_json_by_type(types.DS8K_VOLUME)
class TestRootResourceMixin(TestDS8KWithConnect):
@httpretty.activate
def test_get_system(self):
url = '/systems'
from pyds8k.dataParser.ds8k import ResponseParser, RequestParser
from pyds8k.test.data import get_response_list_json_by_type, \
get_response_list_data_by_type, \
get_response_json_by_type, \
get_response_data_by_type, \
get_request_json_body, create_mappings_response_json
from pyds8k.client.ds8k.v1.sc_client import SCClient
import httpretty
from pyds8k.base import Resource, get_resource_and_manager_class_by_route
system_list_res_json = get_response_list_json_by_type(types.DS8K_SYSTEM)
system_list_res = get_response_list_data_by_type(types.DS8K_SYSTEM)
volume_list_res_json = get_response_list_json_by_type(types.DS8K_VOLUME)
volume_list_res = get_response_list_data_by_type(types.DS8K_VOLUME)
volume_a_res_json = get_response_json_by_type(types.DS8K_VOLUME)
volume_a_res = get_response_data_by_type(types.DS8K_VOLUME)
class TestClient(TestUtils, TestCaseWithConnect):
def setUp(self):
super(TestClient, self).setUp()
self.base_url = Base.base_url
self.rest_client = SCClient('localhost', 'admin', 'admin', '8088')
def _assert_equal_between_dicts(self, returned_dict, origin_dict):
for key, value in origin_dict.items():
if not isinstance(value, dict):
self.assertEqual(value, returned_dict.get(key))
def _assert_equal_between_obj_and_dict(self, returned_obj, origin_dict):
for key, value in origin_dict.items():
