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):
