def test_submittedjob_get_final_output(self):
"""Test _get_final_output"""
_callback = mock.Mock()
resp_a = mock.create_autospec(Response)
resp_a.success = False
resp_a.result = RestCallException(None, "test", None)
resp_b = mock.create_autospec(Response)
resp_b.success = False
resp_b.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
api.props_output.return_value = resp_a
api.get_output.return_value = resp_b
job = SubmittedJob(api, None, None, None)
output = job._get_final_output("", True)
api.props_output.assert_called_with(url=None)
self.assertFalse(api.get_output.called)
job = SubmittedJob(api,
None,
None,
None,
outputLink={'href': 'http://output'})
output = job._get_final_output("", True)
api.props_output.assert_called_with(url='http://output')
self.assertFalse(api.get_output.called)
resp_a.success = True
resp_a.result = 42
output = job._get_final_output("", True)
api.props_output.assert_called_with(url='http://output')
api.get_output.assert_called_with("",
42,
None,
True,
url='http://output',
callback=None,
block=4096)
self.assertEqual(output, resp_b)
output = job._get_final_output("", True, callback=_callback, block=111)
api.get_output.assert_called_with("",
42,
None,
True,
url='http://output',
callback=_callback,
block=111)
def test_pool_update(self):
"""Test delete"""
api = mock.create_autospec(BatchAppsApi)
pool = Pool(api)
api.get_pool.return_value = mock.create_autospec(Response)
api.get_pool.return_value.success = True
api.get_pool.return_value.result = {
'targetDedicated': '5',
'currentDedicated': '4',
'state': 'active',
'allocationState': 'test',
}
self.assertEqual(pool.target_size, 0)
self.assertEqual(pool.current_size, 0)
self.assertEqual(pool.state, None)
self.assertEqual(pool.allocation_state, None)
self.assertEqual(pool.resize_error, '')
pool.update()
api.get_pool.assert_called_with(pool_id=None)
self.assertEqual(pool.target_size, 5)
self.assertEqual(pool.current_size, 4)
self.assertEqual(pool.state, 'active')
self.assertEqual(pool.allocation_state, 'test')
self.assertEqual(pool.resize_error, '')
api.get_pool.return_value.success = False
api.get_pool.return_value.result = RestCallException(
None, "Test", None)
with self.assertRaises(RestCallException):
pool.update()
def test_task_get_output(self, mock_get):
"""Test get_output"""
_callback = mock.Mock()
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
mock_get.return_value = resp
task = Task(api, None)
with self.assertRaises(RestCallException):
task.get_output(None, None)
resp.success = True
output = task.get_output({}, "dir")
mock_get.assert_called_with({},
"dir",
False,
callback=None,
block=4096)
self.assertEqual(output, "dir\\")
output = task.get_output({'name': 'test.txt'},
"dir",
overwrite=True,
callback=_callback,
block=111)
mock_get.assert_called_with({'name': 'test.txt'},
"dir",
True,
callback=_callback,
block=111)
self.assertEqual(output, "dir\\test.txt")
def test_rest_client_put(self, mock_open, mock_call):
"""Test put"""
auth = mock.create_autospec(Credentials)
u_file = mock.create_autospec(UserFile)
u_file.name = "test.jpg"
u_file.path = "testfile"
def _callback(progress, data, total):
self.assertEqual(progress, 0.0)
self.assertIsInstance(progress, float)
self.assertIsInstance(data, int)
self.assertIsInstance(total, int)
with self.assertRaises(RestCallException):
rest_client.put(auth, "http://test//{0}",
{"Content-Type": "application/json"}, u_file, {})
with self.assertRaises(RestCallException):
rest_client.put(auth, "http://test//{0}",
{"Content-Type": "application/json"}, u_file, {
'timestamp': 'a',
'originalFilePath': 'b'
})
val = rest_client.put(auth,
"http://test//{name}",
{"Content-Type": "application/json"},
u_file, {
'timestamp': 'a',
'originalFilePath': 'b'
},
callback=_callback,
block_size=1111)
mock_open.assert_called_with("testfile", 'rb')
mock_call.assert_called_with(
auth,
'PUT',
"http://test//test.jpg",
data=mock.ANY,
params={
'timestamp': 'a',
'originalFilePath': 'b'
},
headers={'Content-Type': 'application/octet-stream'})
self.assertIsNotNone(val)
mock_open.side_effect = OSError("test")
with self.assertRaises(RestCallException):
rest_client.put(auth, "http://test//{name}",
{"Content-Type": "application/json"}, u_file, {
'timestamp': 'a',
'originalFilePath': 'b'
})
mock_open.side_effect = None
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.put(auth, "http://test//{name}",
{"Content-Type": "application/json"}, u_file, {})
def test_rest_client_post(self, mock_call):
"""Test post"""
auth = mock.create_autospec(Credentials)
with self.assertRaises(RestCallException):
rest_client.post(auth, "http://test", {})
mock_call.return_value.text = '{"key":"value"}'
val = rest_client.post(auth, "http://test", {})
mock_call.assert_called_with(auth,
'POST',
"http://test",
headers={},
data=None)
self.assertEqual(val, {"key": "value"})
val = rest_client.post(auth,
"http://test", {},
message={"msg": "test"})
mock_call.assert_called_with(auth,
'POST',
"http://test",
headers={},
data='{"msg": "test"}')
del mock_call.return_value.text
with self.assertRaises(RestCallException):
rest_client.post(auth, "http://test", {})
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.post(auth, "http://test", {})
def get(auth, url, headers, params=None):
"""
Call GET.
:Args:
- auth (:class:`.Credentials`): The session credentials object.
- url (str): The complete endpoint URL.
- headers (dict): The headers to be used in the request.
:Kwargs:
- params (dict): Any additional parameters to be added to the URI as
required by the specified call.
:Returns:
- The data retrieved by the GET call, after json decoding.
:Raises:
- :exc:`.RestCallException` is the call failed,
or returned a non-200 status.
"""
LOG.debug("GET call URL: {0}, params: {1}".format(url, params))
try:
response = _call(auth, 'GET', url, headers=headers, params=params)
return response.json()
except RestCallException:
raise
except ValueError as exp:
raise RestCallException(ValueError,
"No json object to be decoded from GET call.",
exp)
def test_poolmgr_get_pool(self, mock_pool, mock_api, mock_creds, mock_cfg):
"""Test get_pool"""
mgr = PoolManager(mock_creds, cfg=mock_cfg)
with self.assertRaises(ValueError):
mgr.get_pool()
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mgr._client.get_pool.return_value = resp
with self.assertRaises(RestCallException):
mgr.get_pool(url="http://test")
mgr._client.get_pool.assert_called_with(url="http://test")
resp.success = True
resp.result = {'id': '1', 'autoPool': False, 'state': 'test'}
job = mgr.get_pool(url="http://test")
mgr._client.get_pool.assert_called_with(url="http://test")
mock_pool.assert_called_with(mgr._client,
id='1',
autoPool=False,
state="test")
resp.result = {'id': '1', 'name': '2', 'type': '3', 'other': '4'}
job = mgr.get_pool(poolid="test_id")
mgr._client.get_pool.assert_called_with(pool_id="test_id")
def test_submittedjob_get_thumbnail(self, mock_prev):
"""Test get_thumbnail"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mock_prev.return_value = resp
api = mock.create_autospec(BatchAppsApi)
job = SubmittedJob(api, "abc", None, None)
with self.assertRaises(FileDownloadException):
job.get_thumbnail()
self.assertFalse(mock_prev.called)
job = SubmittedJob(api,
"abc",
None,
None,
previewLink={'href': 'http://'})
with self.assertRaises(RestCallException):
job.get_thumbnail()
self.assertTrue(mock_prev.called)
resp.success = True
thumb = job.get_thumbnail(filename="thumb.png")
mock_prev.assert_called_with(tempfile.gettempdir(), "thumb.png", True)
thumb = job.get_thumbnail(download_dir="dir",
filename="thumb.png",
overwrite=False)
mock_prev.assert_called_with("dir", "thumb.png", False)
self.assertEqual(thumb, "dir\\thumb.png")
def test_filemgr_list_files(self, mock_file, mock_api, mock_creds,
mock_cfg):
"""Test list_files"""
mgr = FileManager(mock_creds, cfg=mock_cfg)
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mgr._client.list_files.return_value = resp
with self.assertRaises(RestCallException):
test = mgr.list_files()
self.assertTrue(mgr._client.list_files.called)
self.assertFalse(mock_file.called)
resp.success = True
resp.result = ["test", True, 42, None]
test = mgr.list_files()
self.assertIsInstance(test, list)
mock_file.assert_any_call(mgr._client, "test")
mock_file.assert_any_call(mgr._client, True)
mock_file.assert_any_call(mgr._client, 42)
mock_file.assert_any_call(mgr._client, None)
self.assertEqual(mock_file.call_count, 4)
def test_filemgr_find_files(self, mock_file, mock_api, mock_creds,
mock_cfg):
"""Test find_files"""
mgr = FileManager(mock_creds, cfg=mock_cfg)
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mgr._client.query_files.return_value = resp
with self.assertRaises(RestCallException):
res = mgr.find_files("test")
mgr._client.query_files.assert_called_with("test")
with self.assertRaises(RestCallException):
res = mgr.find_files([None])
mgr._client.query_files.assert_called_with([None])
resp.success = True
resp.result = []
res = mgr.find_files("test")
self.assertEqual(res, [])
self.assertFalse(mock_file.called)
resp.result = ["testFile", None]
res = mgr.find_files("test")
self.assertEqual(len(res), 2)
mock_file.assert_any_call(mgr._client, "testFile")
mock_file.assert_any_call(mgr._client, None)
def test_api_list_tasks(self, mock_url, mock_creds, mock_config, mock_get):
"""Test list_tasks"""
_api = BatchAppsApi(mock_creds, mock_config)
mock_url.return_value = "https://test.com/{jobid}"
mock_get.return_value = {}
val = _api.list_tasks()
self.assertFalse(val.success)
self.assertFalse(mock_get.called)
val = _api.list_tasks(url="http://test")
self.assertFalse(mock_url.called)
self.assertFalse(val.success)
mock_get.assert_called_with(mock_creds, "http://test", self.headers)
mock_get.return_value = {'tasks': None}
val = _api.list_tasks(job_id="test")
mock_get.assert_called_with(mock_creds, "https://test.com/test",
self.headers)
self.assertFalse(val.success)
mock_get.return_value = {'tasks': []}
val = _api.list_tasks(job_id="test")
self.assertTrue(val.success)
self.assertEqual(val.result, [])
mock_get.side_effect = RestCallException(None, "Boom!", None)
val = _api.list_tasks(job_id="test")
self.assertFalse(val.success)
def test_api_get_job(self, mock_url, mock_creds, mock_config, mock_get):
"""Test get_job"""
_api = BatchAppsApi(mock_creds, mock_config)
mock_url.return_value = "https://test_endpoint.com/api/jobs"
mock_get.return_value = None
val = _api.get_job()
self.assertIsInstance(val, Response)
self.assertFalse(val.success)
val = _api.get_job(url="https://job_url")
mock_get.assert_called_with(mock_creds, "https://job_url",
self.headers)
self.assertFalse(val.success)
mock_get.return_value = {'id': '1', 'name': '2', 'type': '3'}
val = _api.get_job(url="https://job_url")
mock_get.assert_called_with(mock_creds, "https://job_url",
self.headers)
self.assertTrue(val.success)
mock_url.return_value = "https://test_endpoint.com/api/{jobid}"
val = _api.get_job(job_id="abcdef")
mock_get.assert_called_with(mock_creds,
"https://test_endpoint.com/api/abcdef",
self.headers)
self.assertTrue(val.success)
self.assertTrue(mock_url.called)
mock_get.side_effect = RestCallException(None, "Boom~", None)
val = _api.get_job(job_id="abcdef")
self.assertFalse(val.success)
def test_rest_client_head(self, mock_call):
"""Test head"""
auth = mock.create_autospec(Credentials)
val = rest_client.head(auth, "http://test", {})
mock_call.assert_called_with(auth, 'HEAD', "http://test", headers={})
with self.assertRaises(RestCallException):
rest_client.head(auth, "http://test/{0}", {})
val = rest_client.head(auth, "http://test/{name}", {})
mock_call.assert_called_with(auth, 'HEAD', "http://test/", headers={})
val = rest_client.head(auth,
"http://test/{name}", {},
filename="test file.jpg")
mock_call.assert_called_with(auth,
'HEAD',
"http://test/test%20file.jpg",
headers={})
mock_call.return_value.headers = {}
with self.assertRaises(RestCallException):
rest_client.head(auth, "http://test", {})
mock_call.return_value.headers = {"content-length": "10"}
val = rest_client.head(auth, "http://test", {})
self.assertEqual(val, 10)
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.head(auth, "http://test", {})
def test_userfile_is_uploaded(self, mock_mod, mock_query, mock_ufile):
"""Test is_uploaded"""
mock_mod.return_value = True
result = mock.create_autospec(UserFile)
result.name = "1"
mock_ufile.return_value = result
api = mock.create_autospec(batchapps.api.BatchAppsApi)
ufile = UserFile(api, {'name':'1'})
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "Boom", None)
api.query_files.return_value = resp
with self.assertRaises(RestCallException):
ufile.is_uploaded()
resp.success = True
resp.result = ['1', '2', '3']
self.assertIsInstance(ufile.is_uploaded(), UserFile)
self.assertTrue(api.query_files.called)
self.assertTrue(mock_query.called)
self.assertEqual(mock_ufile.call_count, 3)
mock_ufile.assert_called_with(mock.ANY, '3')
result.name = "4"
self.assertIsNone(ufile.is_uploaded())
def test_rest_client_get(self, mock_call):
"""Test get"""
auth = mock.create_autospec(Credentials)
rest_client.get(auth, "http://test", {})
mock_call.assert_called_with(auth,
'GET',
"http://test",
headers={},
params=None)
rest_client.get(auth, "http://test", {}, params={'a': 1})
mock_call.assert_called_with(auth,
'GET',
"http://test",
headers={},
params={'a': 1})
mock_call.return_value.json.side_effect = ValueError("Value Error!")
with self.assertRaises(RestCallException):
rest_client.get(auth, "http://test", {})
mock_call.side_effect = RestCallException(None, "Boom!", None)
with self.assertRaises(RestCallException):
rest_client.get(auth, "http://test", {})
def delete(auth, url, headers):
"""
Call DELETE.
Currently only used to delete pools.
:Args:
- auth (:class:`.Credentials`): The session credentials object.
- url (str): The complete endpoint URL.
- headers (dict): The headers to be used in the request.
:Returns:
- The raw server response.
:Raises:
- :exc:`.RestCallException` if the call failed or returned a
non-200 status.
"""
try:
LOG.debug("DELETE call URL: {0}".format(url))
response = _call(auth, 'DELETE', url, headers=headers)
return response
except RestCallException:
raise
except (ValueError, AttributeError) as exp:
raise RestCallException(
ValueError, "No json object to be decoded from DELETE call.", exp)
def test_api_get_pool(self, mock_url, mock_creds, mock_config, mock_get):
"""Test get_pool"""
_api = BatchAppsApi(mock_creds, mock_config)
mock_url.return_value = "https://test_endpoint.com/api/pools"
mock_get.return_value = None
val = _api.get_pool()
self.assertIsInstance(val, Response)
self.assertFalse(val.success)
val = _api.get_pool(url="https://pool_url")
mock_get.assert_called_with(mock_creds, "https://pool_url",
self.headers)
self.assertTrue(val.success)
mock_url.return_value = "https://test_endpoint.com/api/{poolid}"
val = _api.get_pool(pool_id="abcdef")
mock_get.assert_called_with(mock_creds,
"https://test_endpoint.com/api/abcdef",
self.headers)
self.assertTrue(val.success)
self.assertTrue(mock_url.called)
mock_get.side_effect = RestCallException(None, "Boom~", None)
val = _api.get_pool(pool_id="abcdef")
self.assertFalse(val.success)
def test_poolmgr_get_pools(self, mock_pool, mock_api, mock_creds,
mock_cfg):
"""Test get_pools"""
mgr = PoolManager(mock_creds, cfg=mock_cfg)
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
mgr._client.list_pools.return_value = resp
with self.assertRaises(RestCallException):
mgr.get_pools()
mgr._client.list_pools.assert_called_with()
resp.success = True
resp.result = {'pools': []}
pools = mgr.get_pools()
mgr._client.list_pools.assert_called_with()
self.assertEqual(pools, [])
self.assertEqual(len(mgr), 0)
resp.result = {
'totalCount': 1,
'pools': [{
'id': 'abc',
'targetDedicated': '1',
'state': 'active'
}]
}
pools = mgr.get_pools()
mock_pool.assert_called_with(mgr._client, **resp.result['pools'][0])
self.assertEqual(len(pools), 1)
def _call(auth, *args, **kwargs):
"""Internal method to open Requests session."""
try:
conn_session = auth.get_session()
conn_adptr = requests.adapters.HTTPAdapter(max_retries=RETRIES)
conn_session.mount('https://', conn_adptr)
LOG.info("About to make REST call with args {0}".format(args))
LOG.debug("About to make REST call with kwargs {0}".format(kwargs))
LOG.debug(
"Opened requests session with max retries: {0}".format(RETRIES))
response = conn_session.request(*args, **kwargs)
return _check_code(response)
except (oauth2.rfc6749.errors.InvalidGrantError,
oauth2.rfc6749.errors.TokenExpiredError) as exp:
LOG.info("Token expired. Attempting to refresh and continue.")
refreshed_session = auth.refresh_session()
if not refreshed_session:
raise SessionExpiredException("Please log in again. "
"{0}".format(str(exp)))
try:
conn_adptr = requests.adapters.HTTPAdapter(max_retries=RETRIES)
refreshed_session.mount('https://', conn_adptr)
response = refreshed_session.request(*args, **kwargs)
return _check_code(response)
except Exception as exp:
raise RestCallException(
type(exp),
"An {type} error occurred: {error}".format(type=type(exp),
error=str(exp)),
exp)
except (requests.RequestException,
oauth2.rfc6749.errors.OAuth2Error) as exp:
raise RestCallException(
type(exp),
"An {type} error occurred: {error}".format(type=type(exp),
error=str(exp)), exp)
def test_userfile_download(self, mock_size, mock_is_uploaded):
"""Test download"""
_callback = mock.Mock()
mock_size.return_value = 0
api = mock.create_autospec(batchapps.api.BatchAppsApi)
ufile = UserFile(api, {})
download_dir = "test"
mock_is_uploaded.side_effect = RestCallException(None, "Boom", None)
with self.assertRaises(RestCallException):
ufile.download(download_dir)
mock_is_uploaded.side_effect = None
mock_is_uploaded.return_value = None
ufile.download(download_dir)
self.assertFalse(api.props_file.called)
ufile._exists = True
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "Boom", None)
api.props_file.return_value = resp
mock_is_uploaded.return_value = ufile
with self.assertRaises(RestCallException):
ufile.download(download_dir)
self.assertTrue(api.props_file.called)
resp.success = True
resp.result = 123
api.props_file.return_value = resp
r = mock.create_autospec(Response)
r.success = False
r.result = RestCallException(None, "Boom", None)
api.get_file.return_value = r
with self.assertRaises(RestCallException):
ufile.download(download_dir)
api.get_file.assert_called_with(ufile, resp.result, download_dir, callback=None, block=4096)
r.success = True
r.result = "test"
ufile.download(download_dir, callback=_callback, block=1)
api.get_file.assert_called_with(ufile, resp.result, download_dir, callback=_callback, block=1)
def test_track_job_progress(self, mock_check_job, mock_track_tasks):
"""Test _track_job_progress"""
job_mgr = mock.create_autospec(JobManager)
sub = {"jobId": "test", "url": "url_test"}
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, [])
job_mgr.get_job.side_effect = RestCallException(
None, "GetJobFailed", None)
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, sub)
job_mgr.get_job.assert_called_with(jobid="test")
job = mock.create_autospec(SubmittedJob)
job_mgr.get_job.side_effect = None
job_mgr.get_job.return_value = None
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, sub)
client.TIMEOUT = "test"
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, sub)
job_mgr.get_job.return_value = job
job.status = "test"
client.TIMEOUT = 3600
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, sub)
job.name = "MyJob"
job.status = "NotStarted"
job.update.return_value = True
job.percentage = 10
mock_check_job.return_value = True
client.track_job_progress(job_mgr, sub)
self.assertTrue(mock_check_job.called_with(job))
job.status = "Complete"
client.track_job_progress(job_mgr, sub)
job.status = "NotStarted"
client.TIMEOUT = 20
mock_check_job.reset_mock()
mock_check_job.return_value = False
with self.assertRaises(RuntimeError):
client.track_job_progress(job_mgr, sub)
self.assertTrue(mock_check_job.called_with(job))
self.assertEqual(mock_check_job.call_count, 2)
self.assertTrue(mock_track_tasks.called_with(job))
def test_filecoll_is_uploaded(self,
mock_rem,
mock_mess,
mock_ufile,
mock_api):
"""Test is_uploaded"""
def user_file_gen(u_name):
"""Mock UserFile generator"""
ugen = mock.create_autospec(UserFile)
ugen.name = str(u_name)
ugen.compare_lastmodified.return_value = True
return ugen
def add(col, itm):
"""Mock add UserFile to collection"""
col._collection.append(itm)
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "Boom", None)
mock_ufile.return_value = user_file_gen("1")
FileCollection.add = add
mock_api.query_files.return_value = resp
mock_mess.return_value = ["1", "2", "3", "4", "5"]
col = FileCollection(mock_api)
upl = col.is_uploaded()
self.assertIsInstance(upl, FileCollection)
self.assertEqual(upl._collection, col._collection)
self.assertFalse(mock_api.query_files.called)
col._collection = [1, 2, 3, 4, 5]
with self.assertRaises(RestCallException):
col.is_uploaded()
mock_api.query_files.assert_called_once_with(["1", "2", "3", "4", "5"])
with self.assertRaises(RestCallException):
col.is_uploaded(per_call=2)
mock_api.query_files.assert_called_with(["1", "2"])
col._collection = [user_file_gen("1"), user_file_gen("2")]
mock_api.reset()
resp.success = True
resp.result = ["test1", "test2", "test3"]
upl = col.is_uploaded()
mock_api.query_files.assert_called_with(["1", "2", "3", "4", "5"])
mock_rem.assert_called_with([mock.ANY])
self.assertEqual(upl._collection, col._collection)
col._collection = [user_file_gen("test1"), user_file_gen("test2")]
upl = col.is_uploaded()
mock_rem.assert_called_with([])
self.assertEqual(upl._collection, col._collection)
def test_api_query_files(self, mock_url, mock_creds, mock_config,
mock_post):
"""Test query_files"""
_api = BatchAppsApi(mock_creds, mock_config)
mock_url.return_value = "http://test.com/{queryby}"
mock_post.return_value = {}
val = _api.query_files(0)
self.assertFalse(val.success)
self.assertFalse(mock_post.called)
val = _api.query_files([0])
self.assertFalse(val.success)
self.assertFalse(mock_post.called)
val = _api.query_files([])
self.assertFalse(val.success)
self.assertFalse(mock_post.called)
val = _api.query_files({})
mock_post.assert_called_with(mock_creds,
"http://test.com/byspecification",
self.headers, {"Specifications": [{}]})
self.assertFalse(val.success)
val = _api.query_files([{}])
mock_post.assert_called_with(mock_creds,
"http://test.com/byspecification",
self.headers, {"Specifications": [{}]})
self.assertFalse(val.success)
val = _api.query_files("")
mock_post.assert_called_with(mock_creds, "http://test.com/byname",
self.headers, {"Names": [""]})
self.assertFalse(val.success)
val = _api.query_files([""])
mock_post.assert_called_with(mock_creds, "http://test.com/byname",
self.headers, {"Names": [""]})
self.assertFalse(val.success)
mock_post.return_value = {'files': None}
val = _api.query_files([""])
self.assertFalse(val.success)
mock_post.return_value = {'files': []}
val = _api.query_files([""])
self.assertTrue(val.success)
self.assertEqual(val.result, [])
mock_post.side_effect = RestCallException(None, "test", None)
val = _api.query_files([""])
self.assertFalse(val.success)
def test_api_list_outputs(self, mock_url, mock_creds, mock_config,
mock_get):
"""Test list_outputs"""
_api = BatchAppsApi(mock_creds, mock_config)
mock_url.return_value = "https://test_endpoint.com/{jobid}"
mock_get.return_value = {}
val = _api.list_outputs("test_id")
mock_get.assert_called_with(mock_creds,
"https://test_endpoint.com/test_id",
self.headers)
self.assertFalse(val.success)
mock_get.return_value = {'jobOutputs': None}
val = _api.list_outputs("test_id")
mock_get.assert_called_with(mock_creds,
"https://test_endpoint.com/test_id",
self.headers)
self.assertFalse(val.success)
mock_get.return_value = {'jobOutputs': []}
val = _api.list_outputs("test_id")
self.assertTrue(val.success)
self.assertEqual(val.result, [])
mock_get.return_value = {
'jobOutputs': [{
'name': 'output.zip',
'link': {
'href': 'http://url'
},
'kind': 'output'
}]
}
val = _api.list_outputs("test_id")
self.assertTrue(val.success)
self.assertEqual(val.result, [{
'name': 'output.zip',
'link': 'http://url',
'type': 'output'
}])
mock_get.return_value = {'jobOutputs': [{'name': 'output.zip'}]}
val = _api.list_outputs("test_id")
self.assertTrue(val.success)
self.assertEqual(val.result, [{
'name': 'output.zip',
'link': None,
'type': None
}])
mock_get.side_effect = RestCallException(None, "Boom~", None)
val = _api.list_outputs("test_id")
self.assertFalse(val.success)
def post(auth, url, headers, message=None):
"""
Call to POST data to the Batch Apps service.
Used for job submission, job commands and file queries.
:Args:
- auth (:class:`.Credentials`): The session credentials object.
- url (str): The complete endpoint URL.
- headers (dict): The headers to be used in the request.
:Kwargs:
- message (dict): Data to be acted on e.g. job submission
specification, file query parameters. The format and contents will
depend on the specific API call.
:Returns:
- The data in the service response, after json decoding.
:Raises:
- :exc:`.RestCallException` is the call failed, or returned a
non-200 status.
"""
try:
if message:
message = json.dumps(message)
LOG.debug("POST call URL: {0}, message: {1}".format(url, message))
response = _call(auth, 'POST', url, headers=headers, data=message)
return json.loads(response.text)
except RestCallException:
raise
except (ValueError, TypeError) as exp:
raise RestCallException(
type(exp), "No json object to be decoded from POST call.", exp)
except AttributeError as exp:
raise RestCallException(AttributeError,
"Response object has no text attribute.", exp)
def test_submittedjob_reprocess(self):
"""Test reprocess"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
api.reprocess.return_value = resp
job = SubmittedJob(api, "abc", None, None)
working = job.reprocess()
api.reprocess.assert_called_with("abc")
self.assertFalse(working)
resp.result = RestCallException(TypeError, "Boom!", None)
with self.assertRaises(RestCallException):
job.reprocess()
resp.success = True
working = job.reprocess()
self.assertTrue(working)
def test_submittedjob_cancel(self):
"""Test cancel"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
api.cancel.return_value = resp
job = SubmittedJob(api, "abc", None, None)
cancelled = job.cancel()
api.cancel.assert_called_with("abc")
self.assertFalse(cancelled)
resp.result = RestCallException(TypeError, "Boom!", None)
with self.assertRaises(RestCallException):
job.cancel()
resp.success = True
cancelled = job.cancel()
self.assertTrue(cancelled)
def test_task_cancel(self):
"""Test cancel_task"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "test", None)
api = mock.create_autospec(BatchAppsApi)
api.cancel_task.return_value = resp
task = Task(api, "abc")
cancelled = task.cancel()
api.cancel_task.assert_called_with("abc", 0)
self.assertFalse(cancelled)
resp.result = RestCallException(TypeError, "Boom!", None)
with self.assertRaises(RestCallException):
task.cancel()
resp.success = True
cancelled = task.cancel()
self.assertTrue(cancelled)
def head(auth, url, headers, filename=""):
"""
Call HEAD.
This call is only used to retrieve the content-length response
header to get a file size.
:Args:
- auth (:class:`.Credentials`): The session credentials object.
- url (str): The complete endpoint URL.
- headers (dict): The headers to be used in the request.
:Kwargs:
- filename (str): Used to add a filename to the end of the URL if
doesn't already have one. The default is an empty string.
:Returns:
- The content-length header, as an integer.
:Raises:
- :exc:`.RestCallException` if the call failed, returned a non200 status,
or the content-length header was not present in the response object.
"""
try:
url = url.format(name=url_from_filename(filename))
LOG.debug("HEAD call URL: {0}".format(url))
response = _call(auth, 'HEAD', url, headers=headers)
return int(response.headers["content-length"])
except RestCallException:
raise
except KeyError as exp:
raise RestCallException(KeyError,
"No content-length key in response headers.",
exp)
except IndexError as exp:
raise RestCallException(IndexError,
"Incorrectly formatted URL supplied.", exp)
def test_filecoll_upload_thread(self, mock_pik, mock_api):
"""Test upload"""
resp = mock.create_autospec(Response)
resp.success = False
resp.result = RestCallException(None, "Boom", None)
col = FileCollection(mock_api)
col._api = None
failed = col.upload(force=True, threads=1)
self.assertFalse(mock_pik.called)
self.assertEqual(failed, [])
col._collection = [1, 2, 3, 4]
failed = col.upload(force=True, threads=1)
self.assertEqual(mock_pik.call_count, 1)
self.assertEqual(failed,
[(1, "'int' object has no attribute 'upload'"),
(2, "'int' object has no attribute 'upload'"),
(3, "'int' object has no attribute 'upload'"),
(4, "'int' object has no attribute 'upload'")])
mock_pik.call_count = 0
col._collection = [UFile()]
failed = col.upload(force=True, threads=1)
self.assertEqual(mock_pik.call_count, 1)
self.assertEqual(len(failed), 1)
self.assertIsInstance(failed[0], tuple)
mock_pik.call_count = 0
col._collection = [UFile(arg_a=True)]
failed = col.upload(force=True, threads=1)
self.assertEqual(mock_pik.call_count, 1)
self.assertEqual(failed, [])
mock_pik.call_count = 0
col._collection = [UFile(arg_a=True)]
failed = col.upload(force=True, threads=3)
self.assertEqual(mock_pik.call_count, 1)
self.assertEqual(failed, [])
mock_pik.call_count = 0
col._collection = [UFile() for a in range(15)]
failed = col.upload(force=True, threads=3)
self.assertEqual(mock_pik.call_count, 5)
self.assertEqual(len(failed), 15)
mock_pik.call_count = 0
col._collection = [UFile(arg_a=True) for a in range(20)]
failed = col.upload(force=True, threads=20)
self.assertEqual(mock_pik.call_count, 2)
self.assertEqual(failed, [])