def get_cert(subject, days_valid=None, host=None):
"""Access the CADC Certificate Delegation Protocol (CDP) server and
retrieve a X509 proxy certificate.
:param: subject: subject performing the action
:ptype: cadcutils.subject
:param: host: name of the host (overrides the host returned by the service
registry)
:param: days_valid: number of days the proxy certificate is valid for
:ptype daysValid: int
:return content of the certificate
"""
params = {}
if days_valid is not None:
params['daysValid'] = int(days_valid)
client = ws.BaseWsClient(CRED_RESOURCE_ID, subject,
agent="cadc-get-cert/1.0.1", retry=True,
host=host)
response = client.get((CRED_PROXY_FEATURE_ID, None), params=params)
return response.text
def testCalls(self, time_mock):
client = ws.BaseWsClient('https://httpbin.org', net.Subject(), 'FOO')
response = client.get('https://httpbin.org')
self.assertEqual(response.status_code, requests.codes.ok)
with self.assertRaises(exceptions.InternalServerException):
client.get('https://httpbin.org/status/500')
time_mock.reset_mock()
with self.assertRaises(exceptions.HttpException):
client.get('https://httpbin.org/status/503')
calls = [
call(DEFAULT_RETRY_DELAY),
call(min(DEFAULT_RETRY_DELAY * 2, MAX_RETRY_DELAY)),
call(min(DEFAULT_RETRY_DELAY * 4, MAX_RETRY_DELAY)),
call(min(DEFAULT_RETRY_DELAY * 8, MAX_RETRY_DELAY)),
call(min(DEFAULT_RETRY_DELAY * 16, MAX_RETRY_DELAY)),
call(min(DEFAULT_RETRY_DELAY * 32, MAX_RETRY_DELAY))
]
time_mock.assert_has_calls(calls)
def test_misc(self):
"""
Tests miscellaneous functions
"""
service_url = 'http://somehost.com/service'
with patch('cadcutils.net.ws.WsCapabilities') as caps_mock:
caps_mock.return_value.get_service_host.return_value =\
'somehost.com'
caps_mock.return_value.get_access_url.return_value = service_url
client = ws.BaseWsClient("someresourceID", auth.Subject(),
'TestApp')
self.assertEqual('{}'.format(service_url),
client._get_url(('myfeature', None)))
caps_mock.return_value.get_access_url.assert_called_with(
'myfeature')
self.assertEqual('{}'.format(service_url),
client._get_url(('myfeature', '')))
test_host = 'testhost.com'
with patch('cadcutils.net.ws.os.makedirs'):
client = ws.BaseWsClient("someresourceID",
auth.Subject(),
'TestApp',
host=test_host)
self.assertEqual(test_host, client.host)
# test with resource as url
with patch('cadcutils.net.ws.WsCapabilities') as caps_mock:
caps_mock.return_value.get_service_host.return_value =\
'somehost.com'
cm = Mock()
cm.get_access_url.return_value = "http://host/availability"
caps_mock.return_value = cm
client = ws.BaseWsClient("someresourceID", auth.Subject(),
'TestApp')
resource_url = 'http://someurl.com/path/'
self.assertEqual(resource_url, client._get_url(resource_url))
# repeat with overriden host name
client = ws.BaseWsClient("someresourceID",
auth.Subject(),
'TestApp',
host=test_host)
# same result
self.assertEqual(resource_url, client._get_url(resource_url))
# test exceptions with different status in the response
session = ws.RetrySession()
response = requests.Response()
response.status_code = requests.codes.not_found
with self.assertRaises(exceptions.NotFoundException):
session.check_status(response)
response.status_code = requests.codes.unauthorized
with self.assertRaises(exceptions.UnauthorizedException):
session.check_status(response)
response.status_code = requests.codes.forbidden
with self.assertRaises(exceptions.ForbiddenException):
session.check_status(response)
response.status_code = requests.codes.bad_request
with self.assertRaises(exceptions.BadRequestException):
session.check_status(response)
response.status_code = requests.codes.conflict
with self.assertRaises(exceptions.AlreadyExistsException):
session.check_status(response)
response.status_code = requests.codes.internal_server_error
with self.assertRaises(exceptions.InternalServerException):
session.check_status(response)
response.status_code = requests.codes.unavailable
with self.assertRaises(requests.HTTPError):
session.check_status(response)
response.status_code = requests.codes.not_extended
with self.assertRaises(exceptions.UnexpectedException):
session.check_status(response)
def test_ops(self, post_mock, get_mock, delete_mock, head_mock, put_mock,
netrclib_mock, caps_mock):
anon_subject = auth.Subject()
with self.assertRaises(ValueError):
ws.BaseWsClient(None, anon_subject, "TestApp")
resource = 'aresource'
service = 'myservice'
resource_id = 'ivo://www.canfar.phys.uvic.ca/{}'.format(service)
# test anonymous access
cm = Mock()
cm.get_access_url.return_value = "http://host/availability"
caps_mock.return_value = cm
client = ws.BaseWsClient(resource_id, anon_subject, 'TestApp')
resource_uri = urlparse(resource_id)
base_url = 'http://{}{}/pub'.format(resource_uri.netloc,
resource_uri.path)
resource_url = 'http://{}{}/{}'.format(resource_uri.netloc, base_url,
resource)
self.assertEqual(anon_subject, client.subject)
self.assertTrue(client.retry)
self.assertEqual('TestApp', client.agent)
self.assertTrue(client.retry)
self.assertEqual(None, client._session) # lazy initialization
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
# test basic authentication access
post_mock.reset_mock()
get_mock.reset_mock()
put_mock.reset_mock()
delete_mock.reset_mock()
head_mock.reset_mock()
host = 'www.different.org'
subject = auth.Subject(netrc='somecert')
client = ws.BaseWsClient(resource_id,
subject,
'TestApp',
retry=False,
host=host)
base_url = 'http://{}{}/auth'.format(host, resource_uri.path)
resource_url = '{}/{}'.format(base_url, resource)
self.assertEqual('TestApp', client.agent)
self.assertFalse(client.retry)
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
# test cert authentication
post_mock.reset_mock()
get_mock.reset_mock()
put_mock.reset_mock()
delete_mock.reset_mock()
head_mock.reset_mock()
certfile = 'some/certfile.pem'
subject = auth.Subject(certificate=certfile)
client = ws.BaseWsClient(resource_id, subject, 'TestApp')
base_url = 'https://{}{}/pub'.format(resource_uri.netloc,
resource_uri.path)
resource_url = '{}/{}'.format(base_url, resource)
self.assertEqual('TestApp', client.agent)
self.assertTrue(client.retry)
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
self.assertEqual((certfile, certfile), client._session.cert)
# repeat above tests test with the temporary sc2repo test
resource = 'aresource'
service = 'sc2repo'
resource_id = 'ivo://www.canfar.phys.uvic.ca/{}'.format(service)
# test anonymous access
client = ws.BaseWsClient(resource_id, auth.Subject(), 'TestApp')
resource_uri = urlparse(resource_id)
base_url = 'http://{}{}/observations'.format(resource_uri.netloc,
resource_uri.path)
resource_url = '{}/{}'.format(base_url, resource)
self.assertTrue(client.retry)
self.assertEqual('TestApp', client.agent)
self.assertTrue(client.retry)
self.assertEqual(None, client._session) # lazy initialization
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
# test basic authentication access
post_mock.reset_mock()
get_mock.reset_mock()
put_mock.reset_mock()
delete_mock.reset_mock()
head_mock.reset_mock()
host = 'caom2workshop.canfar.net'
subject = auth.Subject(netrc=True)
subject._hosts_auth[host] = ('auser', 'apasswd')
client = ws.BaseWsClient(resource_id,
subject,
'TestApp',
retry=False,
host=host)
base_url = 'http://{}{}/auth-observations'.format(
host, resource_uri.path)
resource_url = '{}/{}'.format(base_url, resource)
self.assertEqual('TestApp', client.agent)
self.assertFalse(client.retry)
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
# test cert authentication
post_mock.reset_mock()
get_mock.reset_mock()
put_mock.reset_mock()
delete_mock.reset_mock()
head_mock.reset_mock()
certfile = 'some/certfile.pem'
client = ws.BaseWsClient(resource_id,
auth.Subject(certificate=certfile), 'TestApp')
base_url = 'https://{}{}/observations'.format(resource_uri.netloc,
resource_uri.path)
resource_url = '{}/{}'.format(base_url, resource)
self.assertEqual('TestApp', client.agent)
self.assertTrue(client.retry)
client.get(resource_url)
get_mock.assert_called_with(resource_url, params=None)
params = {'arg1': 'abc', 'arg2': 123, 'arg3': True}
client.post(resource_url, **params)
post_mock.assert_called_with(resource_url, **params)
client.delete(resource_url)
delete_mock.assert_called_with(resource_url)
client.head(resource_url)
head_mock.assert_called_with(resource_url)
client.put(resource_url, **params)
put_mock.assert_called_with(resource_url, **params)
self.assertTrue(isinstance(client._session, ws.RetrySession))
self.assertEqual((certfile, certfile), client._session.cert)