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_update_host_rm_volumes_all(self):
host_name = 'host1'
url = '/hosts/{}'.format(host_name)
def _verify_request(request, uri, headers):
self.assertEqual(uri, self.domain + self.base_url + url)
resq = RequestParser({'volumes': []})
self.assertEqual(json.loads(request.body), resq.get_request_data())
return (200, headers, action_response_json)
httpretty.register_uri(
httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(DS8K_HOST),
content_type='application/json',
status=200,
)
httpretty.register_uri(httpretty.PUT,
self.domain + self.base_url + url,
body=_verify_request,
content_type='application/json',
)
# Way 1
resp1 = self.system.update_host_rm_volumes_all(host_name)
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(resp1, action_response['server'])
host = self.system.get_host(host_name)
# Way 2
host.volumes = []
resp2, data2 = host.update()
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(data2, action_response['server'])
self.assertEqual(resp2.status_code, 200)
def test_delete_host(self):
host_name = 'host1'
url = '/hosts/{}'.format(host_name)
httpretty.register_uri(
httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(DS8K_HOST),
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_host(host_name)
self.assertEqual(httpretty.DELETE, httpretty.last_request().method)
# self.assertEqual(resp1, action_response['server'])
# Way 2
host = self.system.get_host(host_name)
self.assertIsInstance(host, Host)
resp2, _ = host.delete()
self.assertEqual(resp2.status_code, 204)
self.assertEqual(httpretty.DELETE, httpretty.last_request().method)
def test_update_host_rm_ioports_all(self):
host_name = 'host1'
url = '/hosts/{}'.format(host_name)
def _verify_request(request, uri, headers):
self.assertEqual(uri, self.domain + self.base_url + url)
resq = RequestParser({'ioports': []})
self.assertEqual(json.loads(request.body), resq.get_request_data())
return (200, headers, action_response_json)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(DS8K_HOST),
content_type='application/json',
status=200,
)
httpretty.register_uri(httpretty.PUT,
self.domain + self.base_url + url,
body=_verify_request,
content_type='application/json',
)
# Way 1
resp1 = self.system.update_host_rm_ioports_all(host_name)
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(resp1, action_response['server'])
host = self.system.get_host(host_name)
# Way 2
host.ioports = []
resp2, data2 = host.update()
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(data2, action_response['server'])
self.assertEqual(resp2.status_code, 200)
# Way 3 in DS8K, save works the same as update
host.ioports = []
resp3, data3 = host.save()
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(data3, action_response['server'])
self.assertEqual(resp3.status_code, 200)
# Way 4
host.ioports = []
resp4, data4 = host.patch()
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(data4, action_response['server'])
self.assertEqual(resp4.status_code, 200)
# Way 5 in DS8K, put works the same as patch
host.ioports = []
resp5, data5 = host.put()
self.assertEqual(httpretty.PUT, httpretty.last_request().method)
self.assertEqual(data5, action_response['server'])
self.assertEqual(resp5.status_code, 200)
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_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_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_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_lazy_loading_related_resources_collection(self):
lss_id = '00'
url = '/lss/{}'.format(lss_id)
httpretty.register_uri(httpretty.GET,
self.domain + self.base_url + url,
body=get_response_json_by_type(DS8K_LSS),
content_type='application/json',
status=200,
)
for item in LSS.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,
)
lss = self.system.get_lss_by_id(lss_id)
for item in LSS.related_resources_collection:
res_collection = getattr(lss, 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 _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.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,
self.domain + self.base_url + url,
from pyds8k.resources.ds8k.v1.common.base import Base
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):
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):
self._test_sub_resource_list_by_route(DS8K_POOL, DS8K_TSEREP)
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'
httpretty.register_uri(
