def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.policies = policies.Policies(self.connection)
self.clusters = clusters.OmnistackClusters(self.connection)
self.hosts = hosts.Hosts(self.connection)
self.cluster_groups = cluster_groups.ClusterGroups(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.machines = machines.VirtualMachines(self.connection)
self.policies = policies.Policies(self.connection)
self.datastores = datastores.Datastores(self.connection)
self.clusters = omnistack_clusters.OmnistackClusters(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.backups = backups.Backups(self.connection)
self.datastores = datastores.Datastores(self.connection)
self.virtual_machines = virtual_machines.VirtualMachines(self.connection)
self.clusters = omnistack_clusters.OmnistackClusters(self.connection)
self.cluster_groups = cluster_groups.ClusterGroups(self.connection)
def __init__(self, config):
"""Initialize OVC class."""
self.__connection = Connection(config["ip"],
config.get('ssl_certificate', False),
config.get('timeout'))
if config.get("credentials"):
username = config["credentials"].get("username")
password = config["credentials"].get("password")
self.__connection.login(username, password)
else:
exceptions.HPESimpliVityException("Credentials not provided")
self.__virtual_machines = None
self.__policies = None
self.__datastores = None
self.__omnistack_clusters = None
self.__backups = None
self.__hosts = None
def setUp(self):
self.host = '127.0.0.1'
self.connection = Connection(self.host)
self.connection._access_token = "123456789"
self.new_content_type = {
'Content-type': 'application/vnd.simplivity.v1.7+json'
}
self.default_headers = {'Content-type': 'application/vnd.simplivity.v1.8+json',
'Authorization': 'Bearer 123456789',
'Accept': 'application/json'}
self.updated_headers = self.default_headers.copy()
self.updated_headers.update(self.new_content_type)
self.request_body = {"request body": "content"}
self.response_body = {"response body": "content"}
self.error_response_body = {"message": "this is an error message"}
self.dumped_request_body = json.dumps(self.request_body.copy())
self.expected_response_body = self.response_body.copy()
def setUp(self):
self.Connection = Connection('127.0.0.1')
resource_obj = ResourceStub()
self.resource_client = ResourceClient(self.Connection, resource_obj)
def setUp(self):
self.host = '127.0.0.1'
self.connection = Connection(self.host)
self.task_data = {"state": "IN_PROGRESS", 'id': '123456'}
self.task = Task(self.connection, self.task_data)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.external_stores = external_stores.ExternalStores(self.connection)
self.clusters = clusters.OmnistackClusters(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.cluster_groups = cluster_groups.ClusterGroups(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.clusters = clusters.OmnistackClusters(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.policies = policies.Policies(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.certificates = certificates.Certificates(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.datastores = datastores.Datastores(self.connection)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.backups = backups.Backups(self.connection)
class OVC(object):
"""Client class for all the resources."""
def __init__(self, config):
"""Initialize OVC class."""
self.__connection = Connection(config["ip"], config.get('ssl_certificate', False), config.get('timeout'))
if config.get("credentials"):
username = config["credentials"].get("username")
password = config["credentials"].get("password")
self.__connection.login(username, password)
else:
raise exceptions.HPESimpliVityException("Credentials not provided")
self.__virtual_machines = None
self.__policies = None
self.__datastores = None
self.__omnistack_clusters = None
self.__backups = None
self.__hosts = None
self.__cluster_groups = None
self.__external_stores = None
self.__certificates = None
@classmethod
def from_json_file(cls, file_name):
"""
Construct OVC client using a json file.
Args:
file_name: json full path.
Returns:
OVC object
"""
with open(file_name) as json_data:
config = json.load(json_data)
return cls(config)
@classmethod
def from_environment_variables(cls):
"""
Construct OVC Client using environment variables.
Returns:
OVC object
"""
ip = os.environ.get('SIMPLIVITYSDK_OVC_IP', '')
username = os.environ.get('SIMPLIVITYSDK_USERNAME', '')
password = os.environ.get('SIMPLIVITYSDK_PASSWORD', '')
ssl_certificate = os.environ.get('SIMPLIVITYSDK_SSL_CERTIFICATE', '')
timeout = os.environ.get('SIMPLIVITYSDK_CONNECTION_TIMEOUT')
if not ip or not username or not password:
raise exceptions.HPESimpliVityException("Make sure you have set mandatory env variables \
(SIMPLIVITYSDK_OVC_IP, SIMPLIVITYSDK_USERNAME, SIMPLIVITYSDK_PASSWORD)")
config = dict(ip=ip,
ssl_certificate=ssl_certificate,
credentials=dict(username=username, password=password),
timeout=timeout)
return cls(config)
@property
def connection(self):
"""
Gets the underlying OVC connection used by the OVC client.
Returns:
Connection object
"""
return self.__connection
@property
def virtual_machines(self):
"""
Gets the Virtual Machines client.
Returns:
VirtualMachines object
"""
if not self.__virtual_machines:
self.__virtual_machines = VirtualMachines(self.__connection)
return self.__virtual_machines
@property
def policies(self):
"""
Gets the Policies client.
Returns:
Policies object
"""
if not self.__policies:
self.__policies = Policies(self.__connection)
return self.__policies
@property
def datastores(self):
"""
Gets the Datastores client.
Returns:
Datastores object
"""
if not self.__datastores:
self.__datastores = Datastores(self.__connection)
return self.__datastores
@property
def omnistack_clusters(self):
"""
Gets the Omnistack clusters client.
Returns:
OmnistackClusters object
"""
if not self.__omnistack_clusters:
self.__omnistack_clusters = OmnistackClusters(self.__connection)
return self.__omnistack_clusters
@property
def backups(self):
"""
Gets the Backups client.
Returns:
Backups object
"""
if not self.__backups:
self.__backups = Backups(self.__connection)
return self.__backups
@property
def hosts(self):
"""
Gets the Hosts resource client.
Returns:
Hosts object
"""
if not self.__hosts:
self.__hosts = Hosts(self.__connection)
return self.__hosts
@property
def cluster_groups(self):
"""
Gets the cluster groups client.
Returns:
ClusterGroups object
"""
if not self.__cluster_groups:
self.__cluster_groups = ClusterGroups(self.__connection)
return self.__cluster_groups
@property
def external_stores(self):
"""
Gets the External stores client.
Returns:
External stores object
"""
if not self.__external_stores:
self.__external_stores = ExternalStores(self.__connection)
return self.__external_stores
@property
def certificates(self):
"""
Gets the certificates client.
Returns:
Certificates object
"""
if not self.__certificates:
self.__certificates = Certificates(self.__connection)
return self.__certificates
class ConnectionTest(unittest.TestCase):
def setUp(self):
self.host = '127.0.0.1'
self.connection = Connection(self.host)
self.connection._access_token = "123456789"
self.new_content_type = {
'Content-type': 'application/vnd.simplivity.v1.7+json'
}
self.default_headers = {'Content-type': 'application/vnd.simplivity.v1.8+json',
'Authorization': 'Bearer 123456789',
'Accept': 'application/json'}
self.updated_headers = self.default_headers.copy()
self.updated_headers.update(self.new_content_type)
self.request_body = {"request body": "content"}
self.response_body = {"response body": "content"}
self.error_response_body = {"message": "this is an error message"}
self.dumped_request_body = json.dumps(self.request_body.copy())
self.expected_response_body = self.response_body.copy()
def __make_http_response(self, status, response_body=None):
if response_body is None:
response_body = self.response_body
mock_response = Mock(status=status)
mock_response.read.return_value = json.dumps(response_body).encode('utf-8')
return mock_response
def __create_fake_mapped_file(self):
mock_mapped_file = Mock()
mock_mapped_file.tell.side_effect = [0, 1048576, 2097152, 2621440] # 0, 1MB, 2MB 2.5MB
mock_mapped_file.size.return_value = 2621440 # 2.5MB
mock_mapped_file.read.side_effect = ['data chunck 1', 'data chunck 2', 'data chunck 3']
return mock_mapped_file
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_when_response_is_task(self, mock_response, mock_request):
mock_request.return_value = {}
fake_task = {"task": {"state": "COMPLETED"}}
response = Mock(status=202)
response.read.return_value = json.dumps(fake_task).encode('utf-8')
response.getheader.return_value = ''
mock_response.return_value = response
task, body = self.connection.post('/path', self.request_body)
self.assertEqual(task, fake_task)
self.assertEqual(body, fake_task)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_when_response_is_not_a_task(self, mock_response, mock_request):
mock_request.return_value = {}
response = Mock(status=202)
response.read.return_value = json.dumps(self.response_body).encode('utf-8')
response.getheader.return_value = ''
mock_response.return_value = response
task, body = self.connection.post('/path', self.request_body)
self.assertEqual(task, None)
self.assertEqual(body, self.response_body)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_get_when_status_is_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
body = self.connection.get('/path')
self.assertEqual(body, self.response_body)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_should_do_rest_call_when_status_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
self.connection.post('/path', self.request_body)
mock_request.assert_called_once_with('POST', "https://{}/api/path".format(self.host),
self.dumped_request_body, self.default_headers)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_should_send_updated_headers_when_headers_provided(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=202)
self.connection.post('/path', self.request_body, custom_headers=self.new_content_type)
expected_calls = [call('POST', ANY, ANY, self.updated_headers)]
self.assertEqual(expected_calls, mock_request.call_args_list)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_get_should_raise_exception_when_status_internal_error(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(
status=401,
response_body=self.error_response_body
)
with self.assertRaises(HPESimpliVityException) as context:
self.connection.get('/path')
self.assertTrue(self.error_response_body.get('message') in context.exception.msg)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_should_raise_exception_when_status_internal_error(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(
status=401,
response_body=self.error_response_body
)
with self.assertRaises(HPESimpliVityException) as context:
self.connection.post('/path', self.request_body)
self.assertTrue(self.error_response_body.get('message') in context.exception.msg)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_should_raise_exception_when_status_forbidden(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(
status=403,
response_body=self.error_response_body
)
with self.assertRaises(HPESimpliVityException) as context:
self.connection.post('/path', self.request_body)
self.assertTrue(self.error_response_body.get('message') in context.exception.msg)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_post_should_raise_exception_when_status_not_found(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(
status=404,
response_body=self.error_response_body
)
with self.assertRaises(HPESimpliVityException) as context:
self.connection.post('/path', self.request_body)
self.assertTrue(self.error_response_body.get('message') in context.exception.msg)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_put_should_do_rest_call_when_status_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
self.connection.put('/path', self.request_body)
mock_request.assert_called_once_with('PUT',
'https://{}/api/path'.format(self.host),
self.dumped_request_body, self.default_headers)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_put_should_return_body_when_status_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
result = self.connection.put('/path', self.response_body, custom_headers=self.new_content_type)
expected_result = (None, self.expected_response_body)
self.assertEqual(result, expected_result)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_delete_should_do_rest_calls_when_status_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
self.connection.delete('/path')
mock_request.assert_called_once_with('DELETE',
'https://{}/api/path'.format(self.host),
json.dumps({}), self.default_headers)
@patch.object(HTTPSConnection, 'request')
@patch.object(HTTPSConnection, 'getresponse')
def test_delete_should_return_body_when_status_ok(self, mock_response, mock_request):
mock_request.return_value = {}
mock_response.return_value = self.__make_http_response(status=200)
result = self.connection.delete('/path',
custom_headers=self.new_content_type)
expected_result = (None, self.expected_response_body)
self.assertEqual(result, expected_result)
@patch.object(Connection, 'do_http')
def test_task_in_response_body(self, mock_do_http):
mockedResponse = type('mockResponse', (), {'status': 200})()
mockedTaskBody = {'task': {'state': 'INPROGRESS'}}
mock_do_http.return_value = (mockedResponse, mockedTaskBody)
(testTask, testBody) = self.connection._Connection__do_rest_call('PUT', '/path', '{ "body": "test" }', None)
self.assertEqual(mockedTaskBody, testTask)
self.assertEqual(mockedTaskBody, testBody)
@patch.object(Connection, 'get_connection')
def test_do_http_with_timeout_error(self, mock_get_connection):
mock_conn = mock_get_connection.return_value = Mock()
mock_response = Mock()
mock_conn.getresponse.side_effect = [HTTPException('timed out'), mock_response]
with self.assertRaises(HPESimpliVityException) as context:
resp, body = self.connection.do_http('POST', '/rest/test', 'body')
self.assertTrue('timed out' in context.exception.msg)
def test_do_http_without_access_token(self):
self.connection._access_token = None
with self.assertRaises(HPESimpliVityException) as context:
resp, body = self.connection.do_http('POST', '/rest/test', 'body')
self.assertTrue('please login' in context.exception.msg)
@patch.object(Connection, 'do_http')
def test_login(self, mock_post):
mock_post.return_value = (None, {'access_token': '1234567'})
self.connection.login('username', 'password')
self.assertEqual(self.connection._access_token, '1234567')
@patch.object(Connection, 'do_http')
def test_login_with_unexpected_body(self, mock_post):
mock_post.return_value = (None, {})
with self.assertRaises(HPESimpliVityException) as context:
self.connection.login('username', 'password')
self.assertTrue('Invalid credentials' in context.exception.msg)
@patch.object(Connection, 'login')
@patch.object(Connection, 'get_connection')
def test_login_again_if_token_expired(self, mock_connection, mock_login):
mock_invalid_token_response = self.__make_http_response(
status=401,
response_body={'error': 'invalid_token'}
)
mock_retry_request_response = self.__make_http_response(status=200)
mock_conn = mock_connection.return_value = Mock()
mock_conn.getresponse.side_effect = [mock_invalid_token_response, mock_retry_request_response]
self.connection._username = '******'
self.connection._password = '******'
resp, body = self.connection.do_http('POST', '/rest/test', 'body')
mock_login.assert_called_once_with('username', 'password')
self.assertEqual(body, self.expected_response_body)
def test_logout(self):
self.connection.logout()
self.assertIsNone(self.connection._access_token)
def test_get_connection_ssl_trust_all(self):
conn = self.connection.get_connection()
self.assertEqual(conn.host, '127.0.0.1')
self.assertEqual(conn.port, 443)
self.assertEqual(conn._context.protocol, ssl.PROTOCOL_TLSv1_2)
def setUp(self):
self.connection = Connection('127.0.0.1')
self.connection._access_token = "123456789"
self.hosts = hosts.Hosts(self.connection)
