def _test_resource_list_by_route(self, route, func=None): 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)) url = '/{}'.format(route.replace('.', '/')) base_route = route.split('.')[-1] httpretty.register_uri( httpretty.GET, self.domain + self.base_url + url, body=get_response_list_json_by_type(base_route), content_type='application/json', status=200, ) func = func or 'get_{}'.format(route.replace('.', '_')) res = getattr(self.rest_client, func)() self.assertIsInstance(res, list) self.assertIsInstance(res[0], dict) rep = ResponseParser(get_response_list_data_by_type(base_route), base_route).get_representations()[0] self._assert_equal_between_dicts(res[0], rep)
def test_lazy_loading_related_resources_collection(self): url = '/pools/{}'.format(self.pool_id) httpretty.register_uri( httpretty.GET, self.domain + self.base_url + url, body=response_a_json, content_type='application/json', status=200, ) for item in Pool.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, ) pool = self.system.get_pool(self.pool_id) for item in Pool.related_resources_collection: res_collection = getattr(pool, 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_sub_resource(self, route, route_id, sub_route): sub_route_url = '/{}/{}/{}'.format(route, route_id, sub_route) 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, )
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_list_by_route(self, route, cmp_func=None): res_list_resp = get_response_list_data_by_type(route) url = '/{}'.format(route) res_class = self._get_class_by_name(route) id_field = res_class.id_field cmp_f = cmp_func if cmp_func else self._get_sort_func_by(id_field) httpretty.register_uri( httpretty.GET, self.domain + self.base_url + url, body=get_response_list_json_by_type(route), content_type='application/json', status=200, ) res_list = getattr(self.system, 'get_{}'.format(route))() self.assertIsInstance(res_list[0], res_class) res_list.sort(key=cmp_to_key(cmp_f)) res_list_data = list(res_list_resp['data'][route]) res_list_data.sort(key=cmp_to_key(cmp_f)) self.assertEqual(len(res_list_data), len(res_list)) self._assert_equal_between_sorted_dict_and_resource_list( res_list_data, res_list)
from pyds8k.resources.ds8k.v1.common import types from pyds8k.test.base import TestCaseWithConnect from pyds8k.test.test_resources.test_ds8k.base import TestUtils 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():
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, \ action_response_failed, action_response_failed_json, \ create_host_response_json from .base import TestDS8KWithConnect from pyds8k.resources.ds8k.v1.ioports import IOPort from pyds8k.resources.ds8k.v1.host_ports import HostPort from pyds8k.resources.ds8k.v1.hosts import Host from pyds8k.resources.ds8k.v1.volumes import Volume from pyds8k.dataParser.ds8k import RequestParser volume_list_response = get_response_list_data_by_type(DS8K_VOLUME) volume_list_response_json = get_response_list_json_by_type(DS8K_VOLUME) class TestHost(TestDS8KWithConnect): def test_get_volumes(self): self._test_sub_resource_list_by_route(DS8K_HOST, DS8K_VOLUME, self._sorted_by_volume_name ) def test_get_ioports(self): self._test_sub_resource_list_by_route( DS8K_HOST, DS8K_IOPORT, self._get_sort_func_by(IOPort.id_field) )
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ############################################################################## import httpretty from pyds8k.resources.ds8k.v1.common.types import DS8K_SYSTEM from .base import TestDS8KWithConnect from pyds8k.resources.ds8k.v1.systems import System, \ SystemManager from pyds8k.test.data import get_response_list_json_by_type, \ get_response_list_data_by_type from pyds8k.exceptions import OperationNotAllowed system_list_response = get_response_list_data_by_type(DS8K_SYSTEM) system_list_response_json = get_response_list_json_by_type(DS8K_SYSTEM) class TestSystem(TestDS8KWithConnect): def setUp(self): super(TestSystem, self).setUp() self.system = System(self.client, SystemManager(self.client)) @httpretty.activate def test_get_system(self): url = '/systems' httpretty.register_uri( httpretty.GET, self.domain + self.base_url + url, body=system_list_response_json, content_type='application/json',
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ############################################################################## import httpretty from datetime import datetime from .base import TestDS8KWithConnect from pyds8k.test.data import get_response_list_json_by_type from pyds8k.resources.ds8k.v1.common.types import DS8K_EVENT from pyds8k.exceptions import InvalidArgumentError event_list_response = get_response_list_json_by_type(DS8K_EVENT) class TestHost(TestDS8KWithConnect): @httpretty.activate def test_get_events_by_filter_set_severity(self): url = '/events' httpretty.register_uri(httpretty.GET, self.domain + self.base_url + url, body=event_list_response, content_type='application/json', ) self.system.get_events_by_filter(warning=True, error=True) req = httpretty.last_request()
from pyds8k.resources.ds8k.v1.common import types from pyds8k.test.data import get_response_list_json_by_type, \ get_response_list_data_by_type, \ 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):