def test_server_failed_part(self):
"""Test a failing server for a specific part
This function tests a failed submit on the server side (i.e. code returned is not 200) for a specified part.
"""
# Dummy UUID and part number for testing
uuid = 'BLAH'
part = 3
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with 404 error
rest.expect_get(self._base + '/batch/' + uuid + '/' + str(part), 404,
{})
# Initiate Batch class
batch = Batch()
# Set UUID, parts count, and overall calc state (as 'RUNNING')
batch._uuid = uuid
batch._parts_count = 10
batch._calc_state = 'COMPLETED'
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that a 404 error code will raise a RuntimeError
with self.assertRaises(RuntimeError):
batch.get_part_state(part)
def test_is_not_ready(self):
"""Test when a job is not ready
This function tests that a job will correctly indicate when it is not ready and returns the expected number of
ephemeris parts count.
"""
# Dummy UUID for testing
uuid = 'BLAH'
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with calc_state as 'RUNNING'
rest.expect_get(self._base + '/batch/' + uuid, 200, {
'calc_state': 'RUNNING',
'parts_count': 5
})
# Initiate Batch class
batch = Batch()
# Set UUID
batch._uuid = uuid
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that checking if the batch is ready will return False
self.assertFalse(batch.is_ready())
# Assert that the number of expected parts is returned
self.assertEqual(batch.get_parts_count(), 5)
def test_part_not_in_range(self):
"""Test a part not in the part range
This function tests that a part not within its range will raise an error.
"""
# Dummy UUID and part number for testing
uuid = 'BLAH'
part = 15
# Use REST proxy for testing
rest = _RestProxyForTest()
# Initiate Batch class
batch = Batch()
# Set UUID, parts count, and overall calc state (as 'RUNNING')
batch._uuid = uuid
batch._parts_count = 10
batch._calc_state = 'COMPLETED'
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that a part outside its range will return an IndexError
with self.assertRaises(IndexError):
batch.get_part_state(part)
def test_is_not_ready_part(self):
"""Test when an individual part is not ready
This function tests that a job will correctly indicate when a part is not ready.
"""
# Dummy UUID and part number for testing
uuid = 'BLAH'
part = 3
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with calc_state as 'RUNNING'
rest.expect_get(self._base + '/batch/' + uuid + '/' + str(part), 200, {
'calc_state': 'RUNNING',
'part_index': part
})
# Initiate Batch class
batch = Batch()
# Set UUID, parts count, and overall calc state (as 'RUNNING')
batch._uuid = uuid
batch._parts_count = 10
batch._calc_state = 'RUNNING'
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that checking if the part is ready will return False
self.assertFalse(batch.is_ready_part(part))
def test_is_ready_fails_error_code(self):
"""Test that a failed job returns a RuntimeError when retrieved
This function tests that a failed error code will return a RuntimeError when attempting to check if it is ready.
"""
# Dummy UUID for testing
uuid = 'BLAH'
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with 500 error (fail)
rest.expect_get(self._base + '/batch/' + uuid, 500, {})
# Initiate Batch class
batch = Batch()
# Set UUID
batch._uuid = uuid
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that a RuntimeError is raised when checking if it is ready
with self.assertRaises(RuntimeError):
batch.is_ready()
def test_is_ready_not_found(self):
"""Test that a job is not ready if not found
This function tests that if a job is not found from a UUID, it will not return as 'ready'.
"""
# Dummy UUID for testing
uuid = 'BLAH'
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with 404 error
rest.expect_get(self._base + '/batch/' + uuid, 404, {})
# Initiate Batch class
batch = Batch()
# Set UUID
batch._uuid = uuid
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that the job does not show as ready
self.assertFalse(batch.is_ready())
def _verify_params(self, field):
"""(Private) Verify parameters (fields) raise KeyErrors if not found
This function tests that a given field set to None will raise a KeyError.
Args:
field (str) - attribute to set to None
"""
# Use REST proxy for testing
rest = _RestProxyForTest()
# Initiate Batch class
batch = Batch()
# Set start time, end time, and state vector with epoch
batch.set_start_time("AAA")
batch.set_end_time("BBB")
batch.set_state_vector('CCC', [1, 2, 3, 4, 5, 6])
# Override network access with proxy
batch.set_rest_accessor(rest)
# Set batch attribute (field) to None
setattr(batch, field, None)
# Assert that a missing field will return a KeyError with batch submission
with self.assertRaises(KeyError):
batch.submit()
def test_server_fails(self):
"""Test a failing server
This function tests a failed submit on the server side (i.e. code returned is not 200).
"""
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'POST' request with 404 error
rest.expect_post(self._base + '/batch', lambda x: True, 404, {})
# Initiate Batch class
batch = Batch()
# Set start time, end time, and state vector with epoch
batch.set_start_time("AAA")
batch.set_end_time("BBB")
batch.set_state_vector('CCC', [1, 2, 3, 4, 5, 6])
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that the error code raises a RuntimeError with batch submission
with self.assertRaises(RuntimeError):
batch.submit()
def test_get_ephemeris(self):
"""Test that an ephemeris is returned if the job has completed successfully
This function tests that a job that is completed successfully will return the expected ephemeris.
"""
# Dummy UUID and part number for testing
uuid = 'BLAH'
part = 3
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with calc_state as 'COMPLETED' for specific part
rest.expect_get(
self._base + '/batch/' + uuid + '/' + str(part), 200, {
'calc_state': 'COMPLETED',
'error': 'No error!',
'stk_ephemeris': 'something',
'part_index': part
})
# Initiate Batch class
batch = Batch()
# Set UUID, parts count, and overall calc state (as 'COMPLETED')
batch._uuid = uuid
batch._parts_count = 10
batch._calc_state = 'COMPLETED'
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that an overall calc state as 'COMPLETED' will return the expected ephemeris
self.assertEqual(batch.get_part_ephemeris(part), 'something')
# Assert that the error is as expected
self.assertEqual(batch.get_part_error(part), 'No error!')
# Assert that the calc state for the specific part's run is as expected
self.assertEqual(batch.get_part_state(part), 'COMPLETED')
# Assert that checking if the part is ready will return True
self.assertTrue(batch.is_ready_part(part))
def test_is_ready_fails_no_uuid(self):
"""Test that no specified UUID will raise a KeyError when retrieved
This function tests that checking if a job is ready without specifying the UUID will result in a KeyError.
"""
# Use REST proxy for testing
rest = _RestProxyForTest()
# Initiate Batch class
batch = Batch()
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that a KeyError is raised when checking if it is ready
with self.assertRaises(KeyError):
batch.is_ready()
def test_is_ready_failed_part(self):
"""Test when an individual part has failed
This function tests that a job will correctly indicate when a part has failed, that it returns the expected
error, and that it returns None for ephemeris.
"""
# Dummy UUID and part number for testing
uuid = 'BLAH'
part = 3
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with calc_state as 'FAILED'
rest.expect_get(self._base + '/batch/' + uuid + '/' + str(part), 200, {
'calc_state': 'FAILED',
'error': 'Some error',
'part_index': part
})
# Initiate Batch class
batch = Batch()
# Set UUID, parts count, and overall calc state (as 'FAILED')
batch._uuid = uuid
batch._parts_count = 10
batch._calc_state = 'FAILED'
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that the calc state for the specific part's run is as expected
self.assertEqual(batch.get_part_state(part), 'FAILED')
# Assert that the error returned is as expected
self.assertEqual(batch.get_part_error(part), 'Some error')
# Assert that attempting to retrieve a part's ephemeris will return None
self.assertEqual(batch.get_part_ephemeris(part), None)
def test_is_ready_failed(self):
"""Test that job is ready when failed
This function tests that a job will indicate that it is ready if it has failed.
"""
# Dummy UUID for testing
uuid = 'BLAH'
# Use REST proxy for testing
rest = _RestProxyForTest()
# Set expected 'GET' request with calc_state as 'FAILED'
rest.expect_get(
self._base + '/batch/' + uuid, 200, {
'calc_state': 'FAILED',
'parts_count': 42,
'summary': "ZQZ",
'error': 'No error!'
})
# Initiate Batch class
batch = Batch()
# Set UUID
batch._uuid = uuid
# Override network access with proxy
batch.set_rest_accessor(rest)
# Assert that checking if the batch is ready will return True
self.assertTrue(batch.is_ready())
# Assert that the calc state is as expected
self.assertEqual(batch.get_calc_state(), 'FAILED')
# Assert that the number of expected parts is returned
self.assertEqual(batch.get_parts_count(), 42)
def test_good_submit(self):
"""Test a good/passing batch submit
This function tests a good batch submit run.
"""
# Use REST proxy for testing
rest = _RestProxyForTest()
def check_input(data_dict):
"""Check input data
Checks input data by asserting the following:
- start time = 'AAA'
- end time = 'BBB'
- step size = 86400 (default)
- opm string in data dictionary is not None
- originator = 'ADAM_User'
- object name = 'dummy'
- object ID = '001'
- epoch and state vector are 'CCC' and [1, 2, 3, 4, 5, 6], respectively
- object mass = 1000 (default)
- object solar radiation area = 20 (default)
- object solar radiation coefficient = 1 (default)
- object drag area = 20 (default)
- object drag coefficient = 2.2 (default)
- propagator ID is default (none specified)
Args:
data_dict (dict) - input data for POST
Returns:
True
"""
self.assertEqual(data_dict['start_time'], 'AAA')
self.assertEqual(data_dict['end_time'], 'BBB')
self.assertEqual(data_dict['step_duration_sec'], 86400)
opm = data_dict['opm_string']
self.assertIsNotNone(opm)
self.assertIn('ORIGINATOR = ADAM_User', opm)
self.assertIn('OBJECT_NAME = dummy', opm)
self.assertIn('OBJECT_ID = 001', opm)
self.assertIn('EPOCH = CCC', opm)
self.assertIn('X = 1', opm)
self.assertIn('Y = 2', opm)
self.assertIn('Z = 3', opm)
self.assertIn('X_DOT = 4', opm)
self.assertIn('Y_DOT = 5', opm)
self.assertIn('Z_DOT = 6', opm)
self.assertIn('MASS = 1000', opm)
self.assertIn('SOLAR_RAD_AREA = 20', opm)
self.assertIn('SOLAR_RAD_COEFF = 1', opm)
self.assertIn('DRAG_AREA = 20', opm)
self.assertIn('DRAG_COEFF = 2.2', opm)
self.assertEqual(data_dict['propagator_uuid'],
"00000000-0000-0000-0000-000000000001")
return True
# Set expected 'POST' request (good)
rest.expect_post(self._base + "/batch", check_input, 200, {
'calc_state': 'PENDING',
'uuid': 'BLAH'
})
# Initiate Batch class
batch = Batch()
# Set start time, end time, and state vector with epoch
batch.set_start_time("AAA")
batch.set_end_time("BBB")
batch.set_state_vector('CCC', [1, 2, 3, 4, 5, 6])
# Override network access with proxy
batch.set_rest_accessor(rest)
# Submit job
batch.submit()
# Assert that the calc state is 'PENDING' and the UUID is 'BLAH'
self.assertEqual(batch.get_calc_state(), 'PENDING')
self.assertEqual(batch.get_uuid(), 'BLAH')
def test_custom_inputs(self):
"""Test setting custom inputs
This function tests that setting an optional input will yield that value (instead of the default value).
"""
# Use REST proxy for testing
rest = _RestProxyForTest()
def check_custom_inputs(data_dict):
"""Check custom inputs
Checks input data for custom inputs by asserting the following:
- propagator uuid = 00000000-0000-0000-0000-000000000002
- step size = 216000
- object mass = 500.5
- object solar radiation area = 25.2
- object solar radiation coefficient = 1.2
- object drag area = 33.3
- object drag coefficient = 2.5
Args:
data_dict (dict) - input data for POST
Returns:
True
"""
self.assertEqual(data_dict['propagator_uuid'],
"00000000-0000-0000-0000-000000000002")
self.assertEqual(data_dict['step_duration_sec'], 216000)
self.assertIsNotNone(data_dict['description'])
self.assertEqual(data_dict['description'], 'some description')
opm = data_dict['opm_string']
self.assertIn('ORIGINATOR = Robot', opm)
self.assertIn('OBJECT_NAME = TestObj', opm)
self.assertIn('OBJECT_ID = test1234', opm)
self.assertIn('MASS = 500.5', opm)
self.assertIn('SOLAR_RAD_AREA = 25.2', opm)
self.assertIn('SOLAR_RAD_COEFF = 1.2', opm)
self.assertIn('DRAG_AREA = 33.3', opm)
self.assertIn('DRAG_COEFF = 2.5', opm)
return True
# Set expected 'POST' request (good)
rest.expect_post(self._base + "/batch", check_custom_inputs, 200, {
'calc_state': 'PENDING',
'uuid': 'BLAH'
})
# Initiate Batch class
batch = Batch()
# Set start time, end time, and state vector with epoch
batch.set_start_time("AAA")
batch.set_end_time("BBB")
batch.set_state_vector('CCC', [1, 2, 3, 4, 5, 6])
# Set custom inputs
batch.set_propagator_uuid("00000000-0000-0000-0000-000000000002")
batch.set_step_size(3600, 'min')
batch.set_mass(500.5)
batch.set_solar_rad_area(25.2)
batch.set_solar_rad_coeff(1.2)
batch.set_drag_area(33.3)
batch.set_drag_coeff(2.5)
batch.set_originator('Robot')
batch.set_object_name('TestObj')
batch.set_object_id('test1234')
batch.set_description('some description')
# Override network access with proxy
batch.set_rest_accessor(rest)
# Submit job
batch.submit()
# Assert that the calc state is 'PENDING' and the UUID is 'BLAH'
self.assertEqual(batch.get_calc_state(), 'PENDING')
self.assertEqual(batch.get_uuid(), 'BLAH')
