def __init__(self, *args, **kwargs):
super(TestHttp, self).__init__(*args, **kwargs)
self.client = Client('3',
username='******',
password='******',
token='token',
ecs_endpoint='http://127.0.0.1:4443',
token_endpoint='http://127.0.0.1:4443/login')
def test_client_without_credentials(self):
with self.assertRaises(ECSClientException) as error:
Client(version='3',
ecs_endpoint='https://192.168.1.10',
token_endpoint='https://192.168.10/login')
exception = error.exception.message
self.assertEqual("'token_endpoint' provided but missing ('username','password')", str(exception))
def test_client_v2_class(self):
c = Client(version='2',
username='******',
password='******',
ecs_endpoint='https://192.168.1.10',
token_endpoint='https://192.168.10/login')
self.assertIsInstance(c, v2.client.Client, 'Instance is not a v2 client class')
def test_client_init_with_token_path(self, mock_isfile):
mock_isfile.return_value = True
c = Client(version='3',
token_path='/tmp/mytoken.tkn',
ecs_endpoint='https://192.168.1.10')
self.assertTrue(hasattr(c, 'token_path'))
mock_isfile.assert_called_with('/tmp/mytoken.tkn')
def setUp(self):
super(TestNode, self).setUp()
self.ecs_endpoint = 'https://127.0.0.1:4443'
self.token_endpoint = 'https://127.0.0.1:4443/login'
self.client = Client(
'2',
ecs_endpoint=self.ecs_endpoint,
token_endpoint=self.token_endpoint,
username='******',
password='******'
)
self.returned_json = {
"node": [
{
"ip": "172.29.3.148",
"version": "1.2.0.0.60071.ffbe16c",
"rackId": "gray",
"nodename": "supr01-r01-01.lax01s1.rspaas-lab.ops.com",
"nodeid": "171.29.3.140"
},
{
"ip": "172.29.3.149",
"version": "1.2.0.0.60071.ffbe16c",
"rackId": "gray",
"nodename": "supr01-r01-02.lax01s1.rspaas-lab.ops.com",
"nodeid": "171.29.3.141"
}
]
}
self.response = MagicMock()
self.requests_mock = self.useFixture(fixture.Fixture())
def _get_client(self):
return Client(
self.api_version,
username=self.username,
password=self.password,
ecs_endpoint=self.ecs_endpoint,
token_endpoint=self.token_endpoint)
def test_client_without_ecs_endpoint(self):
with self.assertRaises(ECSClientException) as error:
Client(version='3',
username='******',
password='******',
token_endpoint='https://192.168.10/login')
exception = error.exception.message
self.assertEqual("Missing 'ecs_endpoint'", str(exception))
def test_client_without_version(self):
with self.assertRaises(RuntimeError) as error:
Client(username='******',
password='******',
ecs_endpoint='https://192.168.1.10',
token_endpoint='https://192.168.10/login')
exception = error.exception
self.assertIn('Please provide the API version', str(exception))
def test_client_init_with_credentials(self):
c = Client(version='3',
username='******',
password='******',
token_endpoint='https://192.168.10/login',
ecs_endpoint='https://192.168.1.10')
self.assertTrue(hasattr(c, 'username'))
self.assertTrue(hasattr(c, 'password'))
self.assertTrue(hasattr(c, 'token_endpoint'))
def test_client_unsupported_version(self):
with self.assertRaises(RuntimeError) as error:
Client(version='10',
username='******',
password='******',
ecs_endpoint='https://192.168.1.10',
token_endpoint='https://192.168.10/login')
exception = error.exception
self.assertEqual("No client available for version '10'", str(exception))
def test_client_without_token_endpoint(self, mock_isfile):
mock_isfile.return_value = False
with self.assertRaises(ECSClientException) as error:
Client(version='3',
username='******',
password='******',
ecs_endpoint='https://192.168.1.10')
exception = error.exception.message
mock_isfile.assert_called_with('/tmp/ecsclient.tkn')
self.assertEqual("'token_endpoint' not provided and missing 'token'|'token_path'", str(exception))
def adminLogin(user, password, endpoint):
client = Client('3',
username=user,
password=password,
token_endpoint=endpoint + '/login',
cache_token=False,
ecs_endpoint=endpoint)
print('----------LOGGED IN ADMIN USER IS:')
print(client.user_info.whoami())
print()
return client
def _api_get_client(self):
"""
Returns an instance of ecsclient.client.Client
"""
logging.debug(self.__class__.__name__ + ': ' +
sys._getframe().f_code.co_name)
url = "{0}://{1}:{2}".format(API_PROTOCOL, self.api_endpoint, API_PORT)
logobj(url)
return Client('3',
username=self.ecs.get_root_user(),
password=self.ecs.get_root_pass(),
token_endpoint=url + '/login',
ecs_endpoint=url,
verify_ssl=self.api_verify_ssl,
request_timeout=self.api_timeout)
def get_user_consumption(self):
'''Get the users account usage information'''
client = Client(username=self.username,
password=self.password,
token_endpoint=self.token_endpoint,
ecs_endpoint=self.ecs_endpoint,
request_timeout=self.request_timeout,
verify_ssl=self.verify_ssl,
token_path=self.token_path,
version='3')
namespaces = client.namespace.list(
) # Get all the namespaces in the system
size_dict = {}
quota_dict = {}
for namespace in namespaces['namespace']:
namespace_id = namespace['id']
namespace_name = namespace['name']
logger.debug(namespace_id)
try:
namespace_info = client.billing.get_namespace_billing_info(
namespace_id)
size_dict[namespace_name] = int(namespace_info['total_size'])
quota_info = client.namespace.get_namespace_quota(namespace_id)
quota_dict[namespace_name] = int(quota_info['blockSize'])
except ECSClientException: # Secure buckets dont provide their size
logger.warning(
'Error found in namespace: %s\nException: %s\n skipping',
namespace['name'], Exception)
continue
logger.debug(size_dict)
logger.debug(quota_dict)
client.authentication.logout()
return size_dict, quota_dict
class TestHttp(testtools.TestCase):
TEST_URL = 'http://127.0.0.1:4443/hi'
def __init__(self, *args, **kwargs):
super(TestHttp, self).__init__(*args, **kwargs)
self.client = Client('3',
username='******',
password='******',
token='token',
ecs_endpoint='http://127.0.0.1:4443',
token_endpoint='http://127.0.0.1:4443/login')
def setUp(self):
super(TestHttp, self).setUp()
self.requests_mock = self.useFixture(fixture.Fixture())
def test_get_request_plaintext_resp(self):
self.requests_mock.register_uri('GET', self.TEST_URL, text='resp')
body = self.client.get('hi', params={'key1': 'value1'})
self.assertIsInstance(body, string_types)
self.assertEqual('resp', body)
self.assertEqual(self.requests_mock.last_request.method, 'GET')
self.assertEqual(self.requests_mock.last_request.url,
self.TEST_URL + '?key1=value1')
self.assertEqual(
self.requests_mock.last_request.headers['x-sds-auth-token'],
'token')
def test_get_request_json_resp(self):
self.requests_mock.register_uri('GET',
self.TEST_URL,
text='{"key2": "value2"}')
body = self.client.get('hi', params={'key1': 'value1'})
self.assertIsInstance(body, dict)
self.assertEqual(body['key2'], "value2")
self.assertEqual(self.requests_mock.last_request.method, 'GET')
self.assertEqual(self.requests_mock.last_request.url,
self.TEST_URL + '?key1=value1')
self.assertEqual(
self.requests_mock.last_request.headers['x-sds-auth-token'],
'token')
def test_post_request(self):
self.requests_mock.register_uri('POST', self.TEST_URL, text=None)
payload = {'key1': 'value1', 'key2': 'value2'}
self.client.post('hi', json_payload=payload)
self.assertEqual(self.requests_mock.last_request.method, 'POST')
self.assertEqual(json.loads(self.requests_mock.last_request.text),
payload)
self.assertEqual(self.requests_mock.last_request.url, self.TEST_URL)
self.assertEqual(
self.requests_mock.last_request.headers['x-sds-auth-token'],
'token')
def test_put_request(self):
self.requests_mock.register_uri('PUT', self.TEST_URL, text=None)
payload = {'key1': 'value1', 'key2': 'value2'}
self.client.put('hi', json_payload=payload)
self.assertEqual(self.requests_mock.last_request.method, 'PUT')
self.assertEqual(json.loads(self.requests_mock.last_request.text),
payload)
self.assertEqual(self.requests_mock.last_request.url, self.TEST_URL)
self.assertEqual(
self.requests_mock.last_request.headers['x-sds-auth-token'],
'token')
def test_delete_request(self):
self.requests_mock.register_uri('DELETE', self.TEST_URL, text=None)
self.client.delete('hi')
self.assertEqual(self.requests_mock.last_request.method, 'DELETE')
self.assertEqual(self.requests_mock.last_request.url, self.TEST_URL)
self.assertEqual(
self.requests_mock.last_request.headers['x-sds-auth-token'],
'token')
def test_client_init_with_token(self):
c = Client(version='3',
token='1234567890',
ecs_endpoint='https://192.168.1.10')
self.assertTrue(hasattr(c, 'token'))
