diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/http_client.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/http_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..e37ce2fe9560d50025eced7605d030d1000de1e8
--- /dev/null
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/http_client.py
@@ -0,0 +1,39 @@
+"""
+Base HTTP Client class used so that no matter what http client is used
+the interface to do the request will always be the same
+"""
+
+
+class HTTPClient(object):
+ """ Base HTTP Client class """
+
+ def get(self, url):
+ """
+ Get method placeholder
+ :param url: The url to do a request on
+ """
+ raise NotImplementedError()
+
+ def post(self, url, body):
+ """
+ Post method placeholder
+ :param url: The url to do a post to
+ :param body: The content to post to the url
+ """
+ raise NotImplementedError()
+
+ def put(self, url, body):
+ """
+ Put method placeholder
+ :param url: The url to do a request to
+ :param body: The content to put to
+ """
+ raise NotImplementedError()
+
+ def delete(self, url, body):
+ """
+ Delete method placeholder
+ :param url: The url to do a request on
+ :param body: The content to delete
+ """
+ raise NotImplementedError()
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/oidc_http_client.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/oidc_http_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..9affe7f84331ce447bfb328ee43aae888c984226
--- /dev/null
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/oidc_http_client.py
@@ -0,0 +1,45 @@
+""" Class which uses the BBP oidc client to do http calls """
+
+from hbp_nrp_virtual_coach.http_client import HTTPClient
+
+
+class OIDCHTTPClient(HTTPClient):
+ """ Class which uses the BBP oidc client to do http calls """
+
+ def __init__(self, oidc_username):
+ """
+ :param oidc_username: The HBP oidc username
+ """
+ from bbp_client.oidc.client import BBPOIDCClient
+ self.__oidc_client = BBPOIDCClient.implicit_auth(oidc_username)
+
+ def get(self, url):
+ """
+ :param url: The url to do a request on
+ """
+ response, _ = self.__oidc_client.request(url)
+ return response['status']
+
+ def post(self, url, body):
+ """
+ :param url: The url to do a post to
+ :param body: The content to post to the url
+ """
+ response, content = self.__oidc_client.request(url, method='POST', body=body)
+ return response['status'], content
+
+ def put(self, url, body):
+ """
+ :param url: The url to do a request to
+ :param body: The content to put to
+ """
+ response, content = self.__oidc_client.request(url, method='PUT', body=body)
+ return response['status'], content
+
+ def delete(self, url, body):
+ """
+ :param url: The url to do a request on
+ :param body: The content to delete
+ """
+ response, _ = self.__oidc_client.request(url, method='DELETE', body=body)
+ return response['status']
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/requests_client.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/requests_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..90084942fa2164e98bf4d260ed252e15b7a73c44
--- /dev/null
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/requests_client.py
@@ -0,0 +1,51 @@
+""" Class which uses requests to do http calls """
+
+from hbp_nrp_virtual_coach.http_client import HTTPClient
+import requests
+
+
+class RequestsClient(HTTPClient):
+ """ Class which uses requests to do http calls """
+
+ def __init__(self, headers):
+ """
+ :param headers: The headers to use for each request
+ """
+ self.__headers = headers
+
+ def get(self, url):
+ """
+ :param url: The url to do a request on
+ """
+ response = requests.get(url, headers=self.__headers)
+ return response.status_code, response.content
+
+ def post(self, url, body):
+ """
+ :param url: The url to do a post to
+ :param body: The content to post to the url
+ """
+ if (type(body) != dict):
+ response = requests.post(url, headers=self.__headers, data=body)
+ else:
+ response = requests.post(url, headers=self.__headers, json=body)
+ return response.status_code, response.content
+
+ def put(self, url, body):
+ """
+ :param url: The url to do a request to
+ :param body: The content to put to
+ """
+ if (type(body) != dict):
+ response = requests.put(url, headers=self.__headers, data=body)
+ else:
+ response = requests.put(url, headers=self.__headers, json=body)
+ return response.status_code, response.content
+
+ def delete(self, url, body):
+ """
+ :param url: The url to do a request on
+ :param body: The content to delete
+ """
+ response = requests.delete(url, headers=self.__headers, json=body)
+ return response.status_code
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/simulation.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/simulation.py
index ff113dd81b8a4f32108cb792c3a925779979d2c5..85a57d56aa74682207344a722f8fe3e35726ed0d 100644
--- a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/simulation.py
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/simulation.py
@@ -26,14 +26,13 @@ An interface to launch or control a simulation instance.
"""
from hbp_nrp_virtual_coach.config import Config
-
-from bbp_client.oidc.client import BBPOIDCClient
+from hbp_nrp_virtual_coach.http_client import HTTPClient
import httplib
-import requests
import json
import logging
from urllib2 import HTTPError
+import traceback
class Simulation(object):
@@ -41,19 +40,18 @@ class Simulation(object):
Provides an interface to launch or control a simulation instance.
"""
- def __init__(self, oidc_client, config, storage_headers):
+ def __init__(self, http_client, config):
"""
Initialize a simulation interface and default logger.
- :param oidc_client: An authenticated OIDC client.
+ :param http_client: A HTTP client.
:param config: A loaded Virtual Coach config.
"""
- assert isinstance(oidc_client, BBPOIDCClient)
assert isinstance(config, Config)
+ assert isinstance(http_client, HTTPClient)
- self.__oidc_client = oidc_client
+ self.__http_client = http_client
self.__config = config
- self.__storage_headers = storage_headers
self.__server = None
self.__server_info = None
@@ -71,7 +69,7 @@ class Simulation(object):
self.__logger = logging.getLogger('Simulation')
# pylint: disable=too-many-locals
- def launch(self, experiment_id, experiment_conf, server, reservation):
+ def launch(self, experiment_id, experiment_conf, server, reservation, cloned=True):
"""
Attempt to launch and initialize the given experiment on the given servers. This
should not be directly invoked by users, use the VirtualCoach interface to validate
@@ -102,7 +100,7 @@ class Simulation(object):
# get the information for the server - this provides urls for endpoints
server_info_url = '%s/%s' % (self.__config['proxy-services']['server-info'], server)
- _, server_json = self.__oidc_client.request(server_info_url)
+ _, server_json = self.__http_client.get(server_info_url)
self.__server_info = json.loads(server_json)
# attempt to launch the simulation with given parameters on the server
@@ -113,19 +111,17 @@ class Simulation(object):
'experimentConfiguration': experiment_conf,
'gzserverHost': self.__server_info['serverJobLocation'],
'reservation': reservation,
- 'private': True}
+ 'private': cloned}
- res = requests.post(url, headers=self.__storage_headers, json=sim_info)
- sim_json = res.content
- status = res.status_code
+ status_code, sim_json = self.__http_client.post(url, sim_info)
# check to see if the launch was successful, any other failure return codes
# such as 404 will trigger an exception by the OIDCClient itself
- if status == httplib.CONFLICT:
+ if status_code == httplib.CONFLICT:
raise Exception('Simulation server is launching another experiment.')
- elif status != httplib.CREATED:
- raise Exception("Simulation responded with HTTP status %s" % str(res['status']))
+ elif status_code != httplib.CREATED:
+ raise Exception("Simulation responded with HTTP status %s" % status_code)
# retrieve and store the simulation information
self.__sim_info = json.loads(sim_json)
@@ -141,6 +137,7 @@ class Simulation(object):
except Exception as e:
# print any launch failures and return False so the next server can be tried
self.__logger.error('Unable to launch on %s: %s', server, str(e))
+ traceback.print_exc()
return False
# pylint: disable=import-error
@@ -237,11 +234,11 @@ class Simulation(object):
# attempt to transition the state
self.__logger.info('Attempting to transition to state: %s', state)
url = '%s/%s' % (self.__sim_url, self.__config['simulation-services']['state'])
- res, _ = self.__oidc_client.request(url, method='PUT', body=json.dumps({'state': state}))
+ status_code, _ = self.__http_client.put(url, body={'state': state})
# check the return code, this will return OK if the REST call succeeds
- if res['status'] != str(httplib.OK):
- raise Exception("Unable to set simulation state, HTTP status %s" % str(res['status']))
+ if status_code != httplib.OK:
+ raise Exception("Unable to set simulation state, HTTP status %s" % status_code)
self.__logger.info('Simulation state: %s', state)
def __on_error(self, msg):
@@ -318,13 +315,13 @@ class Simulation(object):
raise Exception("Simulation has not been created, cannot get simulation state!")
url = '%s/%s' % (self.__sim_url, self.__config['simulation-services']['state'])
- response = self.__oidc_client.request(url, method='GET')
+ status_code, content = self.__http_client.get(url)
- if response[0]['status'] != str(httplib.OK):
+ if status_code != httplib.OK:
raise Exception("Unable to get current simulation state, HTTP status %s"
- % str(response[0]['status']))
+ % status_code)
- return str(json.loads(response[1])['state'])
+ return str(json.loads(content)['state'])
def __get_simulation_scripts(self, script_type):
"""
@@ -346,12 +343,13 @@ class Simulation(object):
self.__logger.info("Attempting to retrieve %s" % script_type)
url = '%s/%s' % (self.__sim_url, self.__config['simulation-scripts'][script_type])
- response = self.__oidc_client.request(url, method='GET')
- if response[0]['status'] != str(httplib.OK):
+ status_code, content = self.__http_client.get(url)
+
+ if status_code != httplib.OK:
raise Exception("Unable to get simulation %s, HTTP status %s"
- % (script_type, str(response[0]['status'])))
- return json.loads(response[1])
+ % (script_type, status_code))
+ return json.loads(content)
def __get_script(self, script_name, script_type):
"""
@@ -418,31 +416,31 @@ class Simulation(object):
if script_type == 'transfer-function':
url = '%s/%s' % (self.__sim_url,
self.__config['simulation-scripts'][script_type])
- res, _ = self.__oidc_client.request(url, method='POST', body=script)
+ status_code, _ = self.__http_client.post(url, body=script)
else:
url = '%s/%s/%s' % (self.__sim_url,
self.__config['simulation-scripts'][script_type],
script_name)
- res, _ = self.__oidc_client.request(url, method='PUT', body=script)
+ status_code, _ = self.__http_client.put(url, body=script)
# keep reference to the old script body in case of syntax errors
else:
script_original = defined_scripts[script_name]
url = '%s/%s/%s' % (self.__sim_url,
self.__config['simulation-scripts'][script_type], script_name)
- res, _ = self.__oidc_client.request(url, method='PUT', body=script)
- if res['status'] != str(httplib.OK):
+ status_code, _ = self.__http_client.put(url, body=script)
+ if status_code != httplib.OK:
raise Exception("Unable to set %s, HTTP status %s"
- % (script_type_display, str(res['status'])))
+ % (script_type_display, status_code))
self.__logger.info("%s '%s' successfully updated" % (script_type_display, script_name))
except HTTPError as err:
self.__logger.info(err)
if not new:
self.__logger.info('Attempting to restore the old %s.' % script_type_display)
- res, _ = self.__oidc_client.request(url, method='PUT', body=script_original)
- if res['status'] != str(httplib.OK):
+ status_code, _ = self.__http_client.put(url, body=script_original)
+ if status_code != httplib.OK:
raise Exception("Unable to restore %s, HTTP status %s"
- % (script_type_display, str(res['status'])))
+ % (script_type_display, status_code))
raise Exception("Error detected. The Simulation is now paused.")
@@ -474,11 +472,11 @@ class Simulation(object):
self.__logger.info('Attempting to delete %s %s' % (script_type_display, script_name))
url = '%s/%s/%s' % (self.__sim_url, self.__config['simulation-scripts'][script_type],
script_name)
- res, _ = self.__oidc_client.request(url, method='DELETE', body=script_name)
+ status_code = self.__http_client.delete(url, body=script_name)
- if res['status'] != str(httplib.OK):
+ if status_code != httplib.OK:
raise Exception("Unable to delete %s, HTTP status %s"
- % (script_type_display, str(res['status'])))
+ % (script_type_display, status_code))
self.__logger.info("%s '%s' successfully deleted" % (script_type_display, script_name))
def print_transfer_functions(self):
@@ -544,11 +542,11 @@ class Simulation(object):
self.__experiment_id,
self.__config['simulation-scripts'][experiment_data_type])
try:
- method_fun = getattr(requests, method)
- res = method_fun(url, headers=self.__storage_headers, json=experiment_data)
+ method_fun = getattr(self.__http_client, method)
+ status_code, _ = method_fun(url, body=experiment_data)
- if res.status_code != httplib.OK:
- raise Exception('Error status code %s' % res.status_code)
+ if status_code != httplib.OK:
+ raise Exception('Error status code %s' % status_code)
self.__logger.info("Saved %s." % experiment_data_type)
except Exception as err:
self.__logger.info(err)
@@ -607,10 +605,10 @@ class Simulation(object):
url = '%s/%s' % (self.__sim_url, self.__config['simulation-services']['csv-recorders'])
try:
- res = requests.put(url, headers=self.__storage_headers, json={})
+ status_code, _ = self.__http_client.put(url, body={})
- if res.status_code != httplib.OK:
- raise Exception('Error status code %s' % res.status_code)
+ if status_code != httplib.OK:
+ raise Exception('Error status code %s' % status_code)
self.__logger.info("Saved CSV data")
except Exception as err:
self.__logger.info(err)
@@ -703,19 +701,19 @@ class Simulation(object):
self.pause()
try:
-
- res, _ = self.__oidc_client.request(url, method='PUT', body=json.dumps(body))
- if res['status'] != str(httplib.OK):
- raise Exception("Unable to set Brain, HTTP status %s" % str(res['status']))
+ status_code, _ = self.__http_client.put(url, body=json.dumps(body))
+ if status_code != httplib.OK:
+ raise Exception("Unable to set Brain, HTTP status %s" % status_code)
self.__logger.info("Brain successfully updated.")
except HTTPError as err:
self.__logger.info(err)
self.__logger.info('Attempting to restore the old Brain.')
body['data'] = old_brain
body['additional_populations'] = old_populations
- res, _ = self.__oidc_client.request(url, method='PUT', body=json.dumps(body))
- if res['status'] != str(httplib.OK):
- raise Exception("Unable to restore Brain, HTTP status %s" % str(res['status']))
+
+ status_code, _ = self.__http_client.put(url, body=json.dumps(body))
+ if status_code != httplib.OK:
+ raise Exception("Unable to restore Brain, HTTP status %s" % status_code)
raise Exception("Error detected. The Simulation is now paused and the old script is "
"restored.")
@@ -769,13 +767,13 @@ class Simulation(object):
self.__logger.info("Attempting to retrieve recorders' csv data")
url = '%s/%s' % (self.__sim_url, self.__config['simulation-services']['csv-recorders'])
- response = self.__oidc_client.request(url, method='GET')
+ status_code, content = self.__http_client.get(url)
- if response[0]['status'] != str(httplib.OK):
+ if status_code != httplib.OK:
raise Exception("Unable to get simulation CSV data, HTTP status %s"
- % str(response[0]['status']))
+ % status_code)
- return json.loads(response[1])
+ return json.loads(content)
def __get_csv_file_names(self):
"""
@@ -833,12 +831,11 @@ class Simulation(object):
url = '%s/%s/%s' % (self.__sim_url, self.__experiment_id,
self.__config['simulation-services']['reset'])
body = json.dumps({'resetType': self.__config['reset-services'][reset_type]})
- res, _ = self.__oidc_client.request(url, method='PUT', headers=self.__storage_headers,
- body=body)
+ status_code, _ = self.__http_client.put(url, body=body)
# check the return code, this will return OK if the REST call succeeds
- if res['status'] != str(httplib.OK):
+ if status_code != httplib.OK:
self.start()
- raise Exception("Unable to reset simulation, HTTP status %s" % str(res['status']))
+ raise Exception("Unable to reset simulation, HTTP status %s" % status_code)
self.__logger.info('Reset completed. The simulation has been paused and will not be started'
' automatically.')
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_simulation.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_simulation.py
index 54a8fecf4fd9dd9ac2a96de025352b646584edf9..0314d0d34d3c72fd9d155fb54e1395229312bc7b 100644
--- a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_simulation.py
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_simulation.py
@@ -27,7 +27,7 @@ Unit tests for the Virtual Coach simulation interface.
from hbp_nrp_virtual_coach.simulation import Simulation
-from bbp_client.oidc.client import BBPOIDCClient
+from hbp_nrp_virtual_coach.requests_client import RequestsClient
from hbp_nrp_virtual_coach.config import Config
from mock import Mock, patch, call
@@ -39,19 +39,25 @@ import json
from StringIO import StringIO
-class Response(object):
- status_code = 201
- content = '{"simulationID": "12"}'
-
class TestSimulation(unittest.TestCase):
+
def setUp(self):
- self._sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
+ self._sim = Simulation(RequestsClient({'Authorization': 'token'}), Config('local'))
+
+
+ def setUpForLaunch(self):
+ get_response = (None,
+ '{"serverJobLocation": "mock-location",' \
+ '"gzweb": {"nrp-services": "mock-services"}}')
+ post_response = (httplib.CREATED, '{"simulationID": "12"}')
+ self._sim._Simulation__http_client.get = Mock(return_value=get_response)
+ self._sim._Simulation__http_client.post = Mock(return_value=post_response)
def test_init_asserts(self):
- self.assertRaises(AssertionError, Simulation, None, Config('local'), {'Authorization': 'token'})
- self.assertRaises(AssertionError, Simulation, BBPOIDCClient(), {'Authorization': 'token'}, None)
+ self.assertRaises(AssertionError, Simulation, None, Config('local'))
+ self.assertRaises(AssertionError, Simulation, RequestsClient({'Authorization': 'token'}), None)
def test_launch_asserts(self):
self.assertRaises(AssertionError, self._sim.launch, None, 'conf', 'server', None)
@@ -60,140 +66,54 @@ class TestSimulation(unittest.TestCase):
self.assertRaises(AssertionError, self._sim.launch, 'id', 'conf', 'server', True)
def test_failed_server_info(self):
-
- # mock OIDC call to throw Exception
- self._sim._Simulation__oidc_client.request = Mock()
- self._sim._Simulation__oidc_client.request.side_effect = Exception('something bad failed')
+ # mock HTTP call to throw Exception
+ self.setUpForLaunch()
+ self._sim._Simulation__http_client.get = Mock()
+ self._sim._Simulation__http_client.get.side_effect = Exception('something bad failed')
# make sure it returns failure
self.assertEqual(self._sim.launch('id', 'conf', 'server', None), False)
- self._sim._Simulation__oidc_client.request.assert_called_once()
-
- @patch('requests.post')
- def test_failed_create_conflict(self, mock_request):
-
- class ConflictResponse(object):
- status_code = 409
- content = '{}'
+ self._sim._Simulation__http_client.get.assert_called_once()
+ self._sim._Simulation__http_client.post.assert_not_called()
- mock_request.return_value = ConflictResponse()
-
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- if method is None:
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
-
- # POST for the creation request
- return {'status': str(httplib.CONFLICT)}, '{}'
-
- self._sim._Simulation__oidc_client.request = Mock()
- self._sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ def test_failed_create_conflict(self):
+ self.setUpForLaunch()
+ self._sim._Simulation__http_client.post = Mock(return_value=(httplib.CONFLICT, '{}'))
self.assertEqual(self._sim.launch('id', 'conf', 'server-name', None), False)
- self._sim._Simulation__oidc_client.request.assert_called_once()
-
- @patch('requests.post')
- def test_failed_create_other(self, mock_request):
-
- class FailedResponse(object):
- status_code = 477
- content = '{}'
-
- mock_request.return_value = FailedResponse()
+ self._sim._Simulation__http_client.post.assert_called_once()
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- if method is None:
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
-
- # POST for the creation request
- return {'status': str(httplib.NOT_FOUND)}, '{}'
-
- self._sim._Simulation__oidc_client.request = Mock()
- self._sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ def test_failed_create_other(self):
+ self.setUpForLaunch()
+ self._sim._Simulation__http_client.post = Mock(return_value=(httplib.NOT_FOUND, '{}'))
self.assertEqual(self._sim.launch('id', 'conf', 'server-name', None), False)
- self._sim._Simulation__oidc_client.request.assert_called_once()
-
- @patch('requests.post')
- def test_create(self, mock_request):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- mock_request.return_value = Response()
+ self._sim._Simulation__http_client.post.assert_called_once()
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- if method is None:
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
-
- # POST for the creation request
- return {'status': str(httplib.CREATED)}, '{"simulationID": "12"}'
-
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ def test_create(self):
+ self.setUpForLaunch()
# mock the call to set simulation state
- sim._Simulation__set_state = Mock()
+ self._sim._Simulation__set_state = Mock()
- self.assertEqual(sim.launch('id', 'conf', 'server-name', 'reservation'), True)
+ self.assertEqual(self._sim.launch('id', 'conf', 'server-name', 'reservation'), True)
# calling launch twice on an instance should fail after successful creation
- self.assertRaises(Exception, sim.launch, 'id', 'conf', 'server-name', 'reservation')
-
- @patch('requests.post')
- def test_create_cloned(self, mock_request):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- mock_request.return_value = Response()
-
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
-
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ self.assertRaises(Exception, self._sim.launch, 'id', 'conf', 'server-name', 'reservation')
+ def test_create_cloned(self):
+ self.setUpForLaunch()
# mock the call to set simulation state
- sim._Simulation__set_state = Mock()
-
- self.assertEqual(sim.launch('id', 'conf', 'server-name', 'reservation'), True)
- self.assertEqual(sim._Simulation__oidc_client.request.call_count, 1)
-
- @patch('requests.post')
- def test_create_with_rospy(self, mock_request):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
+ self._sim._Simulation__set_state = Mock()
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- if method is None:
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
+ self.assertEqual(self._sim.launch('id', 'conf', 'server-name', 'reservation'), True)
+ self.assertEqual(self._sim._Simulation__http_client.post.call_count, 1)
- # POST for the creation request
- return {'status': str(httplib.CREATED)}, '{"simulationID": "12"}'
-
- mock_request.return_value = Response()
-
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ def test_create_with_rospy(self):
+ self.setUpForLaunch()
# mock the call to set simulation state
- sim._Simulation__set_state = Mock()
+ self._sim._Simulation__set_state = Mock()
# mock the rospy import since we can't include it as a dependency for the package yet
# based on: http://stackoverflow.com/questions/8658043/how-to-mock-an-import
@@ -206,41 +126,22 @@ class TestSimulation(unittest.TestCase):
return real_import(name, *args)
with patch('__builtin__.__import__', side_effect=mock_import):
- self.assertEqual(sim.launch('id', 'conf', 'server-name', 'reservation'), True)
+ self.assertEqual(self._sim.launch('id', 'conf', 'server-name', 'reservation'), True)
mock_rospy.Subscriber.assert_has_calls([call('/ros_cle_simulation/status',
mock_rospy.String,
- sim._Simulation__on_status),
+ self._sim._Simulation__on_status),
call('/ros_cle_simulation/cle_error',
mock_rospy.CLEError,
- sim._Simulation__on_error)])
+ self._sim._Simulation__on_error)])
- @patch('requests.post')
- def test_create_without_rospy(self, mock_request):
+ def test_create_without_rospy(self):
# this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- class Request(object):
- status_code = 201
- content = '{"simulationID": "12"}'
-
- mock_request.return_value = Request()
-
- # mock OIDC calls to handle request type
- def oidc_mock(url, method=None, body=None):
- # server-info lookup
- if method is None:
- return None, '{"serverJobLocation": "mock-location",' \
- '"gzweb": {"nrp-services": "mock-services"}}'
-
- # POST for the creation request
- return {'status': str(httplib.CREATED)}, '{"simulationID": "12"}'
-
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.side_effect = oidc_mock
+ #sim = Simulation(RequestsClient({'Authorization': 'token'}), Config('local'))
+ self.setUpForLaunch()
# mock the call to set simulation state
- sim._Simulation__set_state = Mock()
+ self._sim._Simulation__set_state = Mock()
# mock the rospy import since we can't include it as a dependency for the package yet
# based on: http://stackoverflow.com/questions/8658043/how-to-mock-an-import
@@ -253,10 +154,10 @@ class TestSimulation(unittest.TestCase):
raise ImportError(name)
return real_import(name, *args)
- sim._Simulation__logger = Mock()
+ self._sim._Simulation__logger = Mock()
with patch('__builtin__.__import__', side_effect=mock_import_fail):
- self.assertEqual(sim.launch('id', 'conf', 'server-name', 'reservation'), True)
+ self.assertEqual(self._sim.launch('id', 'conf', 'server-name', 'reservation'), True)
mock_rospy.assert_not_called()
def test_set_state_asserts(self):
@@ -264,184 +165,150 @@ class TestSimulation(unittest.TestCase):
self.assertRaises(Exception, self._sim._Simulation__set_state, 'foo')
def test_set_state(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- # mock the OIDC call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)}, None)
+ # mock the HTTP call
+ self._sim._Simulation__http_client.put = Mock(return_value=(httplib.OK, None))
- sim._Simulation__set_state('initialized')
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim._Simulation__set_state('initialized')
+ self._sim._Simulation__http_client.put.assert_called_once()
def test_set_state_failed(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ # mock the HTTP call
+ self._sim._Simulation__http_client.put = Mock(return_value=(httplib.NOT_FOUND, None))
- # mock the OIDC call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
- None)
-
- self.assertRaises(Exception, sim._Simulation__set_state, 'started')
- sim._Simulation__oidc_client.request.assert_called_once()
+ self.assertRaises(Exception, self._sim._Simulation__set_state, 'started')
+ self._sim._Simulation__http_client.put.assert_called_once()
def test_states(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the OIDC call
- sim._Simulation__set_state = Mock()
+ self._sim._Simulation__set_state = Mock()
# mock the error subscriber
- sim._Simulation__error_sub = Mock()
+ self._sim._Simulation__error_sub = Mock()
# start
- sim.start()
- sim._Simulation__set_state.assert_called_with('started')
+ self._sim.start()
+ self._sim._Simulation__set_state.assert_called_with('started')
# pause
- sim.pause()
- sim._Simulation__set_state.assert_called_with('paused')
+ self._sim.pause()
+ self._sim._Simulation__set_state.assert_called_with('paused')
# stop
- sim.stop()
- sim._Simulation__set_state.assert_called_with('stopped')
- self.assertEqual(sim._Simulation__error_sub, None)
+ self._sim.stop()
+ self._sim._Simulation__set_state.assert_called_with('stopped')
+ self.assertEqual(self._sim._Simulation__error_sub, None)
def test_get_state(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the OIDC call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
- '{"state": "{}"}')
+ self._sim._Simulation__http_client.get = Mock(return_value=(httplib.OK,
+ '{"state": "{}"}'))
- sim.get_state()
- assert sim._Simulation__oidc_client.request.mock_calls == [call(u'url/state', method='GET')]
+ self._sim.get_state()
+ assert self._sim._Simulation__http_client.get.mock_calls == [call(u'url/state')]
def test_get_state_failed(self):
+ self.assertRaises(Exception, self._sim.get_state)
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- self.assertRaises(Exception, sim.get_state)
-
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the OIDC call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
- None)
- self.assertRaises(Exception, sim.get_state)
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim._Simulation__http_client.get = Mock(return_value=(httplib.NOT_FOUND,
+ None))
+ self.assertRaises(Exception, self._sim.get_state)
+ self._sim._Simulation__http_client.get.assert_called_once()
def test_get_simulation_scripts_asserts(self):
self.assertRaises(AssertionError, self._sim._Simulation__get_simulation_scripts, None)
self.assertRaises(AssertionError, self._sim._Simulation__get_simulation_scripts, 1)
def test_get_simulation_scripts_failed(self):
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- self.assertRaises(Exception, sim._Simulation__get_simulation_scripts, 'state-machine')
+ self.assertRaises(Exception, self._sim._Simulation__get_simulation_scripts, 'state-machine')
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
- sim._Simulation__config = {'simulation-scripts': {'foo': ' '}}
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__config = {'simulation-scripts': {'foo': ' '}}
- self.assertRaises(ValueError, sim._Simulation__get_simulation_scripts, 'bar')
+ self.assertRaises(ValueError, self._sim._Simulation__get_simulation_scripts, 'bar')
# mock the oidc call, the get_all_transfer_function call, the start call, the pause call
# and the get_state call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
- None)
+ self._sim._Simulation__http_client.get = Mock(return_value=(httplib.NOT_FOUND,
+ None))
- self.assertRaises(Exception, sim._Simulation__get_simulation_scripts, 'foo')
+ self.assertRaises(Exception, self._sim._Simulation__get_simulation_scripts, 'foo')
def test_set_script(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts = Mock()
- self.assertRaises(Exception, sim.add_transfer_function, 'foo')
- sim._Simulation__get_simulation_scripts.assert_called_once()
+ self.assertRaises(Exception, self._sim.add_transfer_function, 'foo')
+ self._sim._Simulation__get_simulation_scripts.assert_called_once()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'foo_script_name'}}
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'foo_script_name'}}
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': HTTPError}, None)
+ self._sim._Simulation__http_client.put = Mock(return_value=(HTTPError, None))
- self.assertRaises(Exception, sim._Simulation__set_script, 'foo', 'foo_script_name',
+ self.assertRaises(Exception, self._sim._Simulation__set_script, 'foo', 'foo_script_name',
'foo_script')
- sim.get_state = Mock()
- sim.get_state.return_value = 'started'
+ self._sim.get_state = Mock()
+ self._sim.get_state.return_value = 'started'
- sim.start = Mock()
- sim.pause = Mock()
+ self._sim.start = Mock()
+ self._sim.pause = Mock()
- self.assertRaises(Exception, sim.add_transfer_function, 'foo')
+ self.assertRaises(Exception, self._sim.add_transfer_function, 'foo')
http_error = HTTPError("url", 404, "message", {}, file)
- sim._Simulation__oidc_client.request.side_effect = [http_error,
- ({'status': str(httplib.NOT_FOUND)},
+ self._sim._Simulation__http_client.put.side_effect = [http_error,
+ (httplib.NOT_FOUND,
None)]
- self.assertRaises(Exception, sim.edit_state_machine, 'foo', 'import os\n')
+ self.assertRaises(Exception, self._sim.edit_state_machine, 'foo', 'import os\n')
- sim._Simulation__oidc_client.request.side_effect = [http_error,
- ({'status': str(httplib.OK)}, None)]
- self.assertRaises(Exception, sim.add_state_machine, 'bar', 'import os\n')
+ self._sim._Simulation__http_client.put.side_effect = [http_error,
+ (httplib.OK, None)]
+ self.assertRaises(Exception, self._sim.add_state_machine, 'bar', 'import os\n')
def test_get_transfer_function_asserts(self):
self.assertRaises(AssertionError, self._sim.get_transfer_function, None)
self.assertRaises(Exception, self._sim.get_transfer_function, 'foo')
def test_get_scripts(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'foo_code'}}
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'foo_code'}}
- self.assertEqual(sim.get_transfer_function('foo'), 'foo_code')
- self.assertEqual(sim.get_state_machine('foo'), 'foo_code')
+ self.assertEqual(self._sim.get_transfer_function('foo'), 'foo_code')
+ self.assertEqual(self._sim.get_state_machine('foo'), 'foo_code')
def test_get_transfer_function_failed(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': ''}}
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': ''}}
- self.assertRaises(ValueError, sim.get_transfer_function, 'bar')
- sim._Simulation__get_simulation_scripts.assert_called_once()
+ self.assertRaises(ValueError, self._sim.get_transfer_function, 'bar')
+ self._sim._Simulation__get_simulation_scripts.assert_called_once()
def test_set_transfer_function_asserts(self):
self.assertRaises(AssertionError, self._sim.edit_transfer_function, None, u'foo')
@@ -454,277 +321,240 @@ class TestSimulation(unittest.TestCase):
self.assertRaises(AssertionError, self._sim._Simulation__set_brain, 'foo', {'f': 'b'}, None)
def test_edit_brain_and_populations(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- # mock the oidc call, the get_brain call, the get_populations call, the start call,
+ # mock the http call, the get_brain call, the get_populations call, the start call,
# the pause call, the __get_simulation_scripts call and the get_state call
- sim.get_brain = Mock()
- sim.get_brain.return_value = 'brain_script'
- sim.get_populations = Mock()
- sim.get_populations.return_value = {'foo': 'bar'}
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'brain_type': 'py',
+ self._sim.get_brain = Mock()
+ self._sim.get_brain.return_value = 'brain_script'
+ self._sim.get_populations = Mock()
+ self._sim.get_populations.return_value = {'foo': 'bar'}
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'brain_type': 'py',
'data_type': 'text'}
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
+ self._sim._Simulation__http_client.put = Mock()
+ self._sim._Simulation__http_client.put.return_value = (httplib.OK,
'{"data": {"foo": ""}}')
- sim.get_state = Mock()
- sim.get_state.return_value = 'started'
- sim.pause = Mock()
- sim.start = Mock()
+ self._sim.get_state = Mock()
+ self._sim.get_state.return_value = 'started'
+ self._sim.pause = Mock()
+ self._sim.start = Mock()
- self.assertRaises(Exception, sim.edit_brain, '')
+ self.assertRaises(Exception, self._sim.edit_brain, '')
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- sim.edit_brain('foo')
- sim.start.assert_called_once()
- sim.pause.assert_called_once()
+ self._sim.edit_brain('foo')
+ self._sim.start.assert_called_once()
+ self._sim.pause.assert_called_once()
- # Mock oidc call to return an error
- sim._Simulation__oidc_client.request.return_value = ({'status': HTTPError}, None)
- self.assertRaises(Exception, sim.edit_brain, 'import os\n')
+ # Mock http call to return an error
+ self._sim._Simulation__http_client.put.return_value = (HTTPError, None)
+ self.assertRaises(Exception, self._sim.edit_brain, 'import os\n')
http_error = HTTPError("url", 404, "message", {}, file)
- sim._Simulation__oidc_client.request.side_effect = [http_error,
- ({'status': str(httplib.NOT_FOUND)},
+ self._sim._Simulation__http_client.put.side_effect = [http_error,
+ (httplib.NOT_FOUND,
None)]
- self.assertRaises(Exception, sim.edit_brain, 'foo')
+ self.assertRaises(Exception, self._sim.edit_brain, 'foo')
- sim._Simulation__oidc_client.request.side_effect = [http_error,
- ({'status': str(httplib.OK)}, None)]
- self.assertRaises(Exception, sim.edit_brain, 'foo')
+ self._sim._Simulation__http_client.put.side_effect = [http_error,
+ (httplib.OK, None)]
+ self.assertRaises(Exception, self._sim.edit_brain, 'foo')
- sim._Simulation__set_brain = Mock()
- sim.edit_populations({})
- sim._Simulation__set_brain.assert_called_once()
+ self._sim._Simulation__set_brain = Mock()
+ self._sim.edit_populations({})
+ self._sim._Simulation__set_brain.assert_called_once()
def test_get_brain_and_populations(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': 'foo',
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': 'foo',
'additional_populations': 'bar'}
- sim.get_populations()
- sim._Simulation__get_simulation_scripts.assert_called_once()
- sim._Simulation__get_simulation_scripts.assert_called_with('brain')
+ self._sim.get_populations()
+ self._sim._Simulation__get_simulation_scripts.assert_called_once()
+ self._sim._Simulation__get_simulation_scripts.assert_called_with('brain')
- sim.get_brain()
- sim._Simulation__get_simulation_scripts.assert_called_twice()
- sim._Simulation__get_simulation_scripts.assert_called_with('brain')
+ self._sim.get_brain()
+ self._sim._Simulation__get_simulation_scripts.assert_called_twice()
+ self._sim._Simulation__get_simulation_scripts.assert_called_with('brain')
def test_edit_scripts(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- # mock the oidc call, the get_all_transfer_function call, the start call, the pause call
+ # mock the http call, the get_all_transfer_function call, the start call, the pause call
# and the get_state call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
- '{"data": {"foo": ""}}')
+ self._sim._Simulation__http_client.get = Mock(return_value=(httplib.OK,
+ '{"data": {"foo": ""}}'))
+ self._sim._Simulation__http_client.put = Mock(return_value=(httplib.OK,None))
- sim._Simulation__get_all_transfer_functions = Mock()
- sim._Simulation__get_all_transfer_functions.return_value = {'foo': ''}
- sim._Simulation__get_all_state_machines = Mock()
- sim._Simulation__get_all_state_machines.return_value = {'foo': ''}
+ self._sim._Simulation__get_all_transfer_functions = Mock()
+ self._sim._Simulation__get_all_transfer_functions.return_value = {'foo': ''}
+ self._sim._Simulation__get_all_state_machines = Mock()
+ self._sim._Simulation__get_all_state_machines.return_value = {'foo': ''}
- sim.start = Mock()
- sim.pause = Mock()
+ self._sim.start = Mock()
+ self._sim.pause = Mock()
- sim.get_state = Mock()
- sim.get_state.return_value = 'started'
+ self._sim.get_state = Mock()
+ self._sim.get_state.return_value = 'started'
- sim.edit_transfer_function('foo', u'bar')
- sim.start.assert_called_once()
- sim.pause.assert_called_once()
+ self._sim.edit_transfer_function('foo', u'bar')
+ self._sim.start.assert_called_once()
+ self._sim.pause.assert_called_once()
- sim.edit_state_machine('foo', u'bar')
- sim.start.assert_called_once()
- sim.pause.assert_called_once()
+ self._sim.edit_state_machine('foo', u'bar')
+ self._sim.start.assert_called_once()
+ self._sim.pause.assert_called_once()
def test_delete_scripts(self):
+ self.assertRaises(Exception, self._sim.delete_state_machine, 'foo')
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- self.assertRaises(Exception, sim.delete_state_machine, 'foo')
-
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- # mock the oidc call, the get_all_transfer_function call, the start call, the pause call
+ # mock the http call, the get_all_transfer_function call, the start call, the pause call
# and the get_state call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)}, None)
+ self._sim._Simulation__http_client.delete = Mock(return_value=httplib.OK)
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': '', 'bar': ''}}
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': '', 'bar': ''}}
- sim.delete_state_machine('foo')
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim.delete_state_machine('foo')
+ self._sim._Simulation__http_client.delete.assert_called_once()
- sim.delete_transfer_function('foo')
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim.delete_transfer_function('foo')
+ self._sim._Simulation__http_client.delete.assert_called_once()
- self.assertRaises(ValueError, sim.delete_state_machine, 'nonExistentScript')
+ self.assertRaises(ValueError, self._sim.delete_state_machine, 'nonExistentScript')
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
+ self._sim._Simulation__http_client.delete.return_value = (httplib.NOT_FOUND,
None)
- self.assertRaises(Exception, sim.delete_state_machine, 'foo')
+ self.assertRaises(Exception, self._sim.delete_state_machine, 'foo')
- @patch('requests.post')
- @patch('requests.put')
- def test_save_experiment_data(self, mock_put, mock_post):
-
- sim = Simulation(BBPOIDCClient(), Config('local'), {})
+ def test_save_experiment_data(self):
exp_id = 'exp_id'
serverurl = 'serverurl'
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': ''}}
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': ''}}
- sim.get_transfer_function = Mock()
- sim.get_transfer_function.return_value = 'bar'
+ self._sim.get_transfer_function = Mock()
+ self._sim.get_transfer_function.return_value = 'bar'
- sim.get_state_machine = Mock()
- sim.get_state_machine.return_value = 'bar'
+ self._sim.get_state_machine = Mock()
+ self._sim.get_state_machine.return_value = 'bar'
- sim._Simulation__experiment_id = exp_id
- sim._Simulation__server_info = {
+ self._sim._Simulation__experiment_id = exp_id
+ self._sim._Simulation__server_info = {
'gzweb':{
'nrp-services': serverurl
}
}
- sim._Simulation__headers = {}
-
- class Response(object):
- def __init__(self, status=200):
- self.status_code = status
-
- res_OK = Response(200)
- res_NOK = Response(500)
- mock_put.return_value = res_NOK
+ self._sim._Simulation__headers = {}
- mock_put.return_value = res_OK
- mock_put.reset_mock()
+ self._sim._Simulation__http_client.put = Mock(return_value=(httplib.OK, None))
+
- sim.save_transfer_functions()
- mock_put.assert_called_once('%s/experiment/%s/state-machines' % (serverurl, exp_id),
- headers=sim._Simulation__headers,
- json={'transfer_functions': 'bar',
- 'experimentId': exp_id})
- mock_put.reset_mock()
+ self._sim.save_transfer_functions()
+ self._sim._Simulation__http_client.put.assert_called_once(
+ '%s/experiment/%s/state-machines' % (serverurl, exp_id),
+ body={'transfer_functions': 'bar','experimentId': exp_id})
+ self._sim._Simulation__http_client.put.reset_mock()
- sim.save_state_machines()
- mock_put.assert_called_once_with('%s/experiment/%s/state-machines' % (serverurl, exp_id),
- headers=sim._Simulation__headers,
- json={'state_machines': {'foo': 'bar'},
- 'experimentId': exp_id})
- mock_put.reset_mock()
+ self._sim.save_state_machines()
+ self._sim._Simulation__http_client.put.assert_called_once_with(
+ '%s/experiment/%s/state-machines' % (serverurl, exp_id),
+ body={'state_machines': {'foo': 'bar'}, 'experimentId': exp_id})
+ self._sim._Simulation__http_client.put.reset_mock()
populations = {
'pop1': {'from': 0, 'to': 1, 'step': 1, 'regex': "^\b(?!\bpop0\b)([A-z_]+[\w_]*)$"}}
- sim.get_brain = Mock()
- sim.get_brain.return_value = 'some brain code'
+ self._sim.get_brain = Mock()
+ self._sim.get_brain.return_value = 'some brain code'
- sim.get_populations = Mock()
- sim.get_populations.return_value = populations
- sim.save_transfer_functions = Mock()
+ self._sim.get_populations = Mock()
+ self._sim.get_populations.return_value = populations
+ self._sim.save_transfer_functions = Mock()
- sim.save_brain()
- mock_put.assert_called_once_with('%s/experiment/%s/brain' % (serverurl, exp_id),
- headers=sim._Simulation__headers,
- json={'additional_populations': populations,
- 'data': 'some brain code'})
+ self._sim.save_brain()
+ self._sim._Simulation__http_client.put.assert_called_once_with(
+ '%s/experiment/%s/brain' % (serverurl, exp_id),
+ body={'additional_populations': populations,'data': 'some brain code'})
- mock_post.return_value = res_OK
+ self._sim._Simulation__http_client.post = Mock(return_value=(httplib.OK, None))
+ self._sim.save_world()
+ self._sim._Simulation__http_client.post.assert_called_once_with(
+ '%s/experiment/%s/sdf_world' % (serverurl, exp_id),
+ body={})
- sim.save_world()
- mock_post.assert_called_once_with('%s/experiment/%s/sdf_world' % (serverurl, exp_id),
- headers=sim._Simulation__headers, json={})
+ self._sim._Simulation__http_client.put.reset_mock()
+ self._sim._Simulation__http_client.put = Mock(
+ return_value=(httplib.INTERNAL_SERVER_ERROR, None))
+ self.assertRaises(Exception, self._sim.save_csv)
- mock_put.reset_mock()
- mock_put.return_value = res_NOK
- self.assertRaises(Exception, sim.save_csv)
+ self._sim._Simulation__http_client.put.reset_mock()
+ self._sim._Simulation__sim_url = 'url'
+ self.assertRaises(Exception, self._sim.save_csv)
- mock_put.reset_mock()
- sim._Simulation__sim_url = 'url'
- self.assertRaises(Exception, sim.save_csv)
+ self._sim._Simulation__http_client.put.reset_mock()
+ self._sim._Simulation__http_client.put = Mock(return_value=(httplib.OK, None))
+ self._sim.save_csv()
- mock_put.reset_mock()
- mock_put.return_value = res_OK
- sim.save_csv()
-
- mock_put.assert_called_once_with('%s/csv-recorders' % sim._Simulation__sim_url,
- headers=sim._Simulation__headers,
- json={})
+ self._sim._Simulation__http_client.put.assert_called_once_with(
+ '%s/csv-recorders' % self._sim._Simulation__sim_url,
+ body={})
@patch('sys.stdout', new_callable=StringIO)
def test_print_scripts(self, mock_stdout):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- sim._Simulation__get_simulation_scripts = Mock()
- sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'one', 'bar': 'two',
+ self._sim._Simulation__get_simulation_scripts = Mock()
+ self._sim._Simulation__get_simulation_scripts.return_value = {'data': {'foo': 'one', 'bar': 'two',
'foobar': 'three'}}
- sim.print_transfer_functions()
- sim.print_state_machines()
+ self._sim.print_transfer_functions()
+ self._sim.print_state_machines()
self.assertEqual(mock_stdout.getvalue().strip(), 'foobar\nfoo\nbar\nfoobar\nfoo\nbar')
- sim._Simulation__get_simulation_scripts.assert_called_twice()
+ self._sim._Simulation__get_simulation_scripts.assert_called_twice()
def test_register_status_callback(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
# override the logger so we can check for messages
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__logger = Mock()
+ self._sim._Simulation__logger = Mock()
mock_callback = Mock()
# uninitialized simulation should throw an error
- self.assertRaises(Exception, sim.register_status_callback, mock_callback)
- self.assertEqual(sim._Simulation__logger.info.call_count, 0)
- self.assertEqual(sim._Simulation__logger.warn.call_count, 0)
+ self.assertRaises(Exception, self._sim.register_status_callback, mock_callback)
+ self.assertEqual(self._sim._Simulation__logger.info.call_count, 0)
+ self.assertEqual(self._sim._Simulation__logger.warn.call_count, 0)
# initialized simulation, but no ROS
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
- self.assertRaises(Exception, sim.register_status_callback, mock_callback)
- self.assertEqual(sim._Simulation__logger.info.call_count, 0)
- self.assertEqual(sim._Simulation__logger.warn.call_count, 0)
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
+ self.assertRaises(Exception, self._sim.register_status_callback, mock_callback)
+ self.assertEqual(self._sim._Simulation__logger.info.call_count, 0)
+ self.assertEqual(self._sim._Simulation__logger.warn.call_count, 0)
# successful registration
- sim._Simulation__status_sub = 'subscriber'
- sim.register_status_callback(mock_callback)
- self.assertEqual(sim._Simulation__status_callbacks, [mock_callback])
- sim._Simulation__logger.info.assert_called_once_with('Status callback registered.')
- self.assertEqual(sim._Simulation__logger.warn.call_count, 0)
+ self._sim._Simulation__status_sub = 'subscriber'
+ self._sim.register_status_callback(mock_callback)
+ self.assertEqual(self._sim._Simulation__status_callbacks, [mock_callback])
+ self._sim._Simulation__logger.info.assert_called_once_with('Status callback registered.')
+ self.assertEqual(self._sim._Simulation__logger.warn.call_count, 0)
# ignored duplicate registration
- sim.register_status_callback(mock_callback)
- self.assertEqual(sim._Simulation__status_callbacks, [mock_callback])
- sim._Simulation__logger.warn.assert_called_once_with('Attempting to register duplicate '
+ self._sim.register_status_callback(mock_callback)
+ self.assertEqual(self._sim._Simulation__status_callbacks, [mock_callback])
+ self._sim._Simulation__logger.warn.assert_called_once_with('Attempting to register duplicate '
'status callback, ignoring.')
- self.assertEqual(sim._Simulation__logger.info.call_count, 1)
+ self.assertEqual(self._sim._Simulation__logger.info.call_count, 1)
def test_on_error(self):
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__logger = Mock()
+ self._sim._Simulation__logger = Mock()
class MockMsg(object):
errorType = "test"
@@ -736,140 +566,122 @@ class TestSimulation(unittest.TestCase):
# progress message that should be logged
error_msg = "There was a test error resulting from the test script." \
" The full error is below:\n test body message"
- sim._Simulation__on_error(MockMsg())
- sim._Simulation__logger.error.assert_called_once_with(error_msg)
+ self._sim._Simulation__on_error(MockMsg())
+ self._sim._Simulation__logger.error.assert_called_once_with(error_msg)
def test_on_status(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
# override the logger so we can check for messages
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__logger = Mock()
- sim._Simulation__status_sub = Mock()
- sim._Simulation__error_sub = Mock()
- sim._Simulation__previous_subtask = 'foo'
+ self._sim._Simulation__logger = Mock()
+ self._sim._Simulation__status_sub = Mock()
+ self._sim._Simulation__error_sub = Mock()
+ self._sim._Simulation__previous_subtask = 'foo'
# callback to ensure it is only called when appropriate
mock_callback = Mock()
- sim._Simulation__status_callbacks = [mock_callback]
+ self._sim._Simulation__status_callbacks = [mock_callback]
class MockString(object):
def __init__(self, msg):
self.data = json.dumps(msg)
# progress message that should be discarded
- sim._Simulation__on_status(MockString('action'))
- sim._Simulation__on_status(MockString({'progress': {'done': True}}))
- sim._Simulation__on_status(MockString({'progress': {'subtask': 'foo'}}))
- self.assertEqual(sim._Simulation__logger.info.call_count, 0)
- self.assertEqual(sim._Simulation__status_sub.unregister.call_count, 0)
+ self._sim._Simulation__on_status(MockString('action'))
+ self._sim._Simulation__on_status(MockString({'progress': {'done': True}}))
+ self._sim._Simulation__on_status(MockString({'progress': {'subtask': 'foo'}}))
+ self.assertEqual(self._sim._Simulation__logger.info.call_count, 0)
+ self.assertEqual(self._sim._Simulation__status_sub.unregister.call_count, 0)
self.assertEqual(mock_callback.call_count, 0)
# progress message that should be logged
- sim._Simulation__on_status(MockString({'progress': {'task': 'foo', 'subtask': 'bar'}}))
- sim._Simulation__logger.info.assert_called_once_with('[%s] %s', 'foo', 'bar')
- self.assertEqual(sim._Simulation__status_sub.unregister.call_count, 0)
+ self._sim._Simulation__on_status(MockString({'progress': {'task': 'foo', 'subtask': 'bar'}}))
+ self._sim._Simulation__logger.info.assert_called_once_with('[%s] %s', 'foo', 'bar')
+ self.assertEqual(self._sim._Simulation__status_sub.unregister.call_count, 0)
self.assertEqual(mock_callback.call_count, 0)
# simulation status, callback should be invoked
- sim._Simulation__on_status(MockString({'state': 'paused'}))
+ self._sim._Simulation__on_status(MockString({'state': 'paused'}))
mock_callback.assert_called_once_with({'state': 'paused'})
- self.assertEqual(sim._Simulation__status_sub.unregister.call_count, 0)
- self.assertEqual(sim._Simulation__logger.info.call_count, 1) # from above
+ self.assertEqual(self._sim._Simulation__status_sub.unregister.call_count, 0)
+ self.assertEqual(self._sim._Simulation__logger.info.call_count, 1) # from above
# simulation status for end of the simulation
- sim._Simulation__on_status(MockString({'state': 'stopped'}))
+ self._sim._Simulation__on_status(MockString({'state': 'stopped'}))
mock_callback.assert_called_with({'state': 'stopped'})
- self.assertEqual(sim._Simulation__status_sub, None)
- self.assertEqual(sim._Simulation__error_sub, None)
- self.assertEqual(sim._Simulation__status_callbacks, [])
- sim._Simulation__logger.info.assert_called_with('Simulation has been stopped.')
+ self.assertEqual(self._sim._Simulation__status_sub, None)
+ self.assertEqual(self._sim._Simulation__error_sub, None)
+ self.assertEqual(self._sim._Simulation__status_callbacks, [])
+ self._sim._Simulation__logger.info.assert_called_with('Simulation has been stopped.')
def test_get_all_csv_data(self):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the oidc call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
+ self._sim._Simulation__http_client.get = Mock()
+ self._sim._Simulation__http_client.get.return_value = (httplib.OK,
'[{"data": [], "file": "spikes"}]')
- files = sim._Simulation__get_csv_file_names()
- sim._Simulation__oidc_client.request.assert_called_once()
+ files = self._sim._Simulation__get_csv_file_names()
+ self._sim._Simulation__http_client.get.assert_called_once()
self.assertEqual(files, ['spikes'])
def test_get_all_csv_data_failed(self):
+ self.assertRaises(Exception, self._sim._Simulation__get_all_csv_data)
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
-
- self.assertRaises(Exception, sim._Simulation__get_all_csv_data)
-
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the OIDC call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
+ self._sim._Simulation__http_client.get = Mock()
+ self._sim._Simulation__http_client.get.return_value = (httplib.NOT_FOUND,
None)
- self.assertRaises(Exception, sim._Simulation__get_all_csv_data)
- sim._Simulation__oidc_client.request.assert_called_once()
+ self.assertRaises(Exception, self._sim._Simulation__get_all_csv_data)
+ self._sim._Simulation__http_client.get.assert_called_once()
def test_get_csv_data(self):
self.assertRaises(AssertionError, self._sim.get_csv_data, None)
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
+ self._sim._Simulation__http_client.get = Mock()
+ self._sim._Simulation__http_client.get.return_value = (httplib.OK,
'[{"data": ["1,10.0", "2,15.0"],'
'"file": "spikes"}]')
- self.assertEqual(sim.get_csv_data('spikes'), [['1', '10.0'], ['2', '15.0']])
- self.assertRaises(ValueError, sim.get_csv_data, 'joints')
+ self.assertEqual(self._sim.get_csv_data('spikes'), [['1', '10.0'], ['2', '15.0']])
+ self.assertRaises(ValueError, self._sim.get_csv_data, 'joints')
@patch('sys.stdout', new_callable=StringIO)
def test_print_csv_file_names(self, mock_stdout):
-
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
# mock the oidc call
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)},
+ self._sim._Simulation__http_client.get = Mock()
+ self._sim._Simulation__http_client.get.return_value = (httplib.OK,
'[{"data": [], "file": "spikes"}]')
- sim.print_csv_file_names()
+ self._sim.print_csv_file_names()
self.assertEqual(mock_stdout.getvalue().strip(), "[u'spikes']")
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim._Simulation__http_client.get.assert_called_once()
def test_reset(self):
+ self._sim._Simulation__server = 'server'
+ self._sim._Simulation__sim_url = 'url'
- # this will create a sim, don't store it in class since we can't guarantee order
- sim = Simulation(BBPOIDCClient(), Config('local'), {'Authorization': 'token'})
- sim._Simulation__server = 'server'
- sim._Simulation__sim_url = 'url'
-
- sim.pause = Mock()
+ self._sim.pause = Mock()
- sim._Simulation__oidc_client.request = Mock()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.OK)}, None)
+ self._sim._Simulation__http_client.put = Mock()
+ self._sim._Simulation__http_client.put.return_value = (httplib.OK, None)
- sim.reset('world')
- sim._Simulation__oidc_client.request.assert_called_once()
+ self._sim.reset('world')
+ self._sim._Simulation__http_client.put.assert_called_once()
- sim._Simulation__oidc_client.request.return_value = ({'status': str(httplib.NOT_FOUND)},
+ self._sim._Simulation__http_client.put.return_value = (httplib.NOT_FOUND,
None)
- sim.start = Mock()
+ self._sim.start = Mock()
- self.assertRaises(ValueError, sim.reset, 'foo')
- self.assertRaises(Exception, sim.reset, 'full')
- sim.start.assert_called_once()
+ self.assertRaises(ValueError, self._sim.reset, 'foo')
+ self.assertRaises(Exception, self._sim.reset, 'full')
+ self._sim.start.assert_called_once()
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_virtual_coach.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_virtual_coach.py
index 5da507d918af4a37cea05a0040003de5391abf04..3c2509a21cff829c81b4da9c419aedd1fa5a266a 100644
--- a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_virtual_coach.py
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/tests/test_virtual_coach.py
@@ -254,8 +254,8 @@ class TestVirtualCoach(unittest.TestCase):
if i == '3':
return None, json.dumps({'displayName': 'User Three'})
- self._vc._VirtualCoach__oidc_client.request = Mock()
- self._vc._VirtualCoach__oidc_client.request.side_effect = fake_user_lookup
+ self._vc._VirtualCoach__http_client.get = Mock()
+ self._vc._VirtualCoach__http_client.get.side_effect = fake_user_lookup
# mock the current time (so that the table prints consistently)
mock_date.now = Mock(return_value=parser.parse('Feb 03 12:20:03 UTC 2017'))
@@ -296,7 +296,7 @@ mock-server-5
@patch('sys.stdout', new_callable=StringIO)
def test_print_no_available_servers(self, mock_stdout, available_servers, mock_getpass):
- # mock the OIDC server call
+ # mock the HTTP server call
available_servers.return_value = []
self._vc.print_available_servers()
@@ -307,8 +307,8 @@ mock-server-5
def test_get_experiment_list(self, password):
# mock the request
- self._vc._VirtualCoach__oidc_client.request = Mock()
- self._vc._VirtualCoach__oidc_client.request.return_value = 'x', json.dumps(self._mock_exp_list)
+ self._vc._VirtualCoach__http_client.get = Mock()
+ self._vc._VirtualCoach__http_client.get.return_value = 'x', json.dumps(self._mock_exp_list)
list_json = self._vc._VirtualCoach__get_experiment_list()
self.assertEqual(list_json, self._mock_exp_list)
@@ -389,7 +389,7 @@ mock-server-5
self._vc._VirtualCoach__storage_username = 'username'
self._vc._VirtualCoach__storage_headers = {'Authorization': 'token'}
- def launch(experiment_id, experiment_conf, server, reservation):
+ def launch(experiment_id, experiment_conf, server, reservation, cloned):
if server == 'mock-server-1':
raise Exception('fake failure!')
return True
diff --git a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/virtual_coach.py b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/virtual_coach.py
index bd67c814e7a7dd3a300268e84ba6ff174a2f3022..10221b8b17ecaf03c16bdc61dd4958234ac01e6f 100644
--- a/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/virtual_coach.py
+++ b/hbp_nrp_virtual_coach/hbp_nrp_virtual_coach/virtual_coach.py
@@ -27,8 +27,8 @@ Virtual Coach main entry point for interacting with the experiment list and laun
from hbp_nrp_virtual_coach.config import Config
from hbp_nrp_virtual_coach.simulation import Simulation
-
-from bbp_client.oidc.client import BBPOIDCClient
+from hbp_nrp_virtual_coach.requests_client import RequestsClient
+from hbp_nrp_virtual_coach.oidc_http_client import OIDCHTTPClient
from datetime import datetime, timedelta
from dateutil import parser, tz
@@ -36,6 +36,7 @@ import json
import requests
import logging
import getpass
+import httplib
from texttable import Texttable
logger_format = '%(levelname)s: [%(asctime)s - %(name)s] %(message)s'
@@ -50,7 +51,8 @@ class VirtualCoach(object):
view available experiments, query currently running experiments, launch a simulation, and more.
"""
- def __init__(self, environment=None, oidc_username=None, storage_username=None):
+ def __init__(self, environment=None, oidc_username=None,
+ storage_username=None, storage_password=None):
"""
Instantiates the Virtual Coach by loading the configuration file and logging into OIDC for
the given user. This will only fail if the config file is invalid or if the user
@@ -68,6 +70,8 @@ class VirtualCoach(object):
:param storage_username: (optional) A string representing the Storage Server username. It is
required if the user wants to have access to the storage server to
clone experiments and launch cloned experiments.
+ :param storage_password: (optional) A string representing the Storage Server password. If
+ not supplied, the user will be prompted to enter a password.
"""
assert isinstance(environment, (str, type(None)))
assert isinstance(oidc_username, (str, type(None)))
@@ -103,18 +107,20 @@ class VirtualCoach(object):
if oidc_username:
# this will interactively prompt the user for a password in terminal if needed
logger.info('Logging into OIDC as: %s', oidc_username)
- self.__oidc_client = BBPOIDCClient.implicit_auth(oidc_username)
+ self.__http_client = OIDCHTTPClient(oidc_username)
# if a Storage Server username is provided, attempt to login
elif storage_username:
# this will interactively prompt the user for a password in terminal
logger.warn('No OIDC username supplied, simulation services will fail if OIDC is '
'enabled in this environment (%s).', environment)
logger.info('Logging into the Storage Server as: %s', storage_username)
- storage_password = getpass.getpass()
+ if not storage_password:
+ storage_password = getpass.getpass()
self.__storage_headers = {'Content-Type': 'application/json',
'Authorization': 'Bearer %s' % self.__get_storage_token(
storage_username, storage_password)}
- self.__oidc_client = BBPOIDCClient()
+
+ self.__http_client = RequestsClient(self.__storage_headers)
else:
raise Exception('Virtual Coach instantiated without storage server credentials or oidc'
'credentials. You have to provide either one with the keywords '
@@ -176,9 +182,9 @@ class VirtualCoach(object):
# readable owner name instead of just their system id
# use a default user name if an oidc_username hasn't been provided
if self.__oidc_username is not None:
- _, user_json = self.__oidc_client.request(
- '%s/%s' % (self.__config['oidc']['user'], r['owner']))
- owner = json.loads(user_json)['displayName']
+ url = '%s/%s' % (self.__config['oidc']['user'], r['owner'])
+ _, content = self.__http_client.get(url)
+ owner = json.loads(content)['displayName']
else:
owner = "local_user"
@@ -214,7 +220,7 @@ class VirtualCoach(object):
logger.info('Available servers:')
print '\n'.join(servers)
- def launch_experiment(self, experiment_id, server=None, reservation=None):
+ def launch_experiment(self, experiment_id, server=None, reservation=None, cloned=True):
"""
Attempts to launch a simulation with the given parameters. If no server is explicitly given
then all available backend servers will be tried. Only cloned experiments to the Storage
@@ -226,6 +232,8 @@ class VirtualCoach(object):
provided, then all backend servers will be checked.
:param reservation: (optional) A cluster reservation string if the user has reserved
specific resources, otherwise use any available resources.
+ :param cloned: (optional) True or False depending on if the launched
+ is a cloned experiment or not.
"""
assert isinstance(experiment_id, str)
assert isinstance(server, (str, type(None)))
@@ -234,7 +242,7 @@ class VirtualCoach(object):
# retrieve the list of cloned experiments to verify that the given id is valid for the
# backend
logger.info('Preparing to launch %s.', experiment_id)
- exp_list = self.__get_experiment_list(cloned=True)
+ exp_list = self.__get_experiment_list(cloned)
if experiment_id not in exp_list:
raise ValueError('Experiment ID: "%s" is invalid, you can only launch experiments '
'located in your storage space. You can check your experiments with '
@@ -246,7 +254,11 @@ class VirtualCoach(object):
from pprint import pprint
pprint(available_servers)
servers = [available_server['id'] for available_server in available_servers]
- experiment_conf = ""
+ if cloned:
+ experiment_conf = ""
+ else:
+ experiment = exp_list[experiment_id]
+ experiment_conf = experiment['configuration']['experimentConfiguration']
# if the user provided a specific server, ensure it is available before trying to launch
if server is not None:
@@ -261,10 +273,11 @@ class VirtualCoach(object):
# attempt to launch the simulation on all server targets, on success return an interface
# to the simulation
- sim = Simulation(self.__oidc_client, self.__config, self.__storage_headers)
+ sim = Simulation(self.__http_client, self.__config)
for server in servers:
try:
- if sim.launch(experiment_id, str(experiment_conf), str(server), reservation):
+ if sim.launch(experiment_id, str(experiment_conf), str(server),
+ reservation, cloned):
return sim
# pylint: disable=broad-except
@@ -292,13 +305,13 @@ class VirtualCoach(object):
exp_config_path = exp[exp_id]['configuration']['experimentConfiguration']
body = {'expPath': exp_config_path}
- res = requests.post(self.__config['proxy-services']['experiment-clone'], json=body,
- headers=self.__storage_headers)
- if res.status_code != 200:
- raise Exception('Cloning Experiment failed, Status Code: %s' % res.status_code)
+ status_code, content = self.__http_client.post(
+ self.__config['proxy-services']['experiment-clone'], body=body)
+ if status_code != 200:
+ raise Exception('Cloning Experiment failed, Status Code: %s' % status_code)
else:
logger.info('Experiment "%s" cloned successfully', exp_id)
- return res.content
+ return content
def delete_cloned_experiment(self, exp_id):
"""
@@ -311,8 +324,8 @@ class VirtualCoach(object):
raise ValueError('Experiment ID: "%s" is invalid, the experiment does not exist in your'
' storage. Please check the list of all experiments: \n%s'
% (exp_id, exp_list))
- requests.delete(self.__config['proxy-services']['experiment-delete'] + exp_id,
- headers=self.__storage_headers)
+ self.__http_client.delete(self.__config['proxy-services']['experiment-delete'] + exp_id,
+ body={})
logger.info('Experiment "%s" deleted successfully', exp_id)
def clone_cloned_experiment(self, experiment_id):
@@ -394,8 +407,8 @@ class VirtualCoach(object):
# information in the dictionary anyway
return [experiment['name'] for experiment in json.loads(response.content)]
else:
- _, response = self.__oidc_client.request(
- self.__config['proxy-services']['experiment-list'], headers=headers)
+ _, response = self.__http_client.get(
+ self.__config['proxy-services']['experiment-list'])
return json.loads(response)
def __get_available_server_list(self):
@@ -403,7 +416,10 @@ class VirtualCoach(object):
Internal helper to retrieve the available server list from the backend proxy.
"""
logger.info('Retrieving list of available servers.')
- _, response = self.__oidc_client.request(
+ status_code, response = self.__http_client.get(
self.__config['proxy-services']['available-servers'])
+ if str(status_code) != str(httplib.OK):
+ raise Exception('Error when getting server list, Status Code: %d. Error: %s'
+ % (status_code, response))
return json.loads(response)