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(