class TransportTestCase(unittest.TestCase):
def setUp(self):
os.environ['espa_api_testing'] = 'True'
# create a user
self.mock_user = MockUser()
self.mock_order = MockOrder()
self.user = User.find(self.mock_user.add_testing_user())
self.order_id = self.mock_order.generate_testing_order(self.user.id)
self.app = http.app.test_client()
self.app.testing = True
self.sceneids = self.mock_order.scene_names_list(self.order_id)[0:2]
token = ''.format(self.user.username, 'foo')
auth_string = "Basic {}".format(base64.b64encode(token))
self.headers = {"Authorization": auth_string}
with db_instance() as db:
uidsql = "select user_id, orderid from ordering_order limit 1;"
db.select(uidsql)
self.userid = db[0]['user_id']
self.orderid = db[0]['orderid']
itemsql = "select name, order_id from ordering_scene limit 1;"
db.select(itemsql)
self.itemid = db[0][0]
itemorderid = db[0][1]
ordersql = "select orderid from ordering_order where id = {};".format(
itemorderid)
db.select(ordersql)
self.itemorderid = db[0][0]
self.base_order = lowercase_all(testorders.build_base_order())
def tearDown(self):
# clean up orders
self.mock_order.tear_down_testing_orders()
# clean up users
self.mock_user.cleanup()
os.environ['espa_api_testing'] = ''
def test_get_api_response_type(self):
response = self.app.get('/api',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
assert response.content_type == 'application/json'
def test_get_api_response_content(self):
response = self.app.get('/api',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(set(['1', '0']), set(resp_json.keys()))
@patch('api.domain.user.User.get', MockUser.get)
def test_get_api_info_response_content(self):
response = self.app.get('/api/v1',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "Version 1" in resp_json['description']
@patch('api.domain.user.User.get', MockUser.get)
@patch(
'api.providers.ordering.ordering_provider.OrderingProvider.available_products',
mock_api.available_products)
def test_get_available_prods(self):
url = '/api/v1/available-products/' + ",".join(self.sceneids)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "etm" in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
@patch(
'api.providers.ordering.ordering_provider.OrderingProvider.available_products',
mock_api.available_products)
def test_post_available_prods(self):
url = '/api/v1/available-products'
data_dict = {'inputs': self.sceneids}
response = self.app.post(url,
data=json.dumps(data_dict),
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "etm" in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
@patch(
'api.providers.ordering.ordering_provider.OrderingProvider.fetch_user_orders',
mock_ordering_provider.fetch_user_orders)
def test_get_available_orders_user(self):
url = "/api/v1/list-orders"
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert resp_json.keys() == ['orders']
@patch('api.domain.user.User.get', MockUser.get)
def test_get_available_orders_email(self):
# email param comes in as unicode
url = "/api/v1/list-orders/" + str(self.user.email)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert resp_json.keys() == ['orders']
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_by_ordernum(self):
url = "/api/v1/order/" + str(self.orderid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_status_by_ordernum(self):
url = "/api/v1/order-status/" + str(self.orderid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum(self):
url = "/api/v1/item-status/%s" % self.itemorderid
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum_itemnum(self):
url = "/api/v1/item-status/%s/%s" % (self.itemorderid, self.itemid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_current_user(self):
url = "/api/v1/user"
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'username' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_projections(self):
url = '/api/v1/projections'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'aea' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_formats(self):
url = '/api/v1/formats'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'formats' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_resampling(self):
url = '/api/v1/resampling-methods'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'resampling_methods' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_schema(self):
url = '/api/v1/order-schema'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'properties' in resp_json.keys()
# Waiting for DB mock-ups to be finished
def test_post_order(self):
pass
class ProductionTransportTestCase(unittest.TestCase):
def setUp(self):
os.environ['espa_api_testing'] = 'True'
# create a user
self.mock_user = MockUser()
self.mock_order = MockOrder()
self.user = User.find(self.mock_user.add_testing_user())
self.order_id = self.mock_order.generate_testing_order(self.user.id)
self.app = http.app.test_client()
self.app.testing = True
self.sceneids = self.mock_order.scene_names_list(self.order_id)[0:2]
with db_instance() as db:
uidsql = "select user_id, orderid from ordering_order limit 1;"
db.select(uidsql)
self.userid = db[0]['user_id']
self.orderid = db[0]['orderid']
itemsql = "select name, order_id from ordering_scene limit 1;"
db.select(itemsql)
self.itemid = db[0][0]
itemorderid = db[0][1]
ordersql = "select orderid from ordering_order where id = {};".format(
itemorderid)
db.select(ordersql)
self.itemorderid = db[0][0]
self.base_order = lowercase_all(testorders.build_base_order())
def tearDown(self):
# clean up orders
self.mock_order.tear_down_testing_orders()
# clean up users
self.mock_user.cleanup()
os.environ['espa_api_testing'] = ''
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_get_production_api(self):
response = self.app.get('/production-api',
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response.content_type == 'application/json'
assert set(response_data.keys()) == set(['0', '1'])
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_get_production_api_v1(self):
response = self.app.get('/production-api/v1',
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert set(response_data.keys()) == set(["operations", "description"])
assert "ESPA Production" in response_data['description']
@patch(
'api.providers.production.production_provider.ProductionProvider.get_products_to_process',
production_provider.get_products_to_process_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_get_production_api_products_modis(self):
url = "/production-api/v1/products?for_user=bilbo&product_types=modis"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
correct_resp = {
'encode_urls': False,
'for_user': '******',
'record_limit': 500,
'product_types': 'modis',
'priority': None
}
assert response_data == correct_resp
@patch(
'api.providers.production.production_provider.ProductionProvider.get_products_to_process',
production_provider.get_products_to_process_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_get_production_api_products_landsat(self):
url = "/production-api/v1/products?for_user=bilbo&product_types=landsat"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
correct_resp = {
'encode_urls': False,
'for_user': '******',
'record_limit': 500,
'product_types': 'landsat',
'priority': None
}
assert response_data == correct_resp
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
@patch(
'api.providers.production.production_provider.ProductionProvider.update_status',
production_provider.update_status_inputs)
def test_post_production_api_update_status(self):
url = "/production-api/v1/update_status"
data_dict = {
'name': 't10000xyz401',
'orderid': '[email protected]',
'processing_loc': 'update_status',
'status': 'updated'
}
response = self.app.post(url,
data=json.dumps(data_dict),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch(
'api.providers.production.production_provider.ProductionProvider.set_product_error',
production_provider.set_product_error_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_post_production_api_set_product_error(self):
url = "/production-api/v1/set_product_error"
data_dict = {
'name': 't10000xyz401',
'orderid': '[email protected]',
'processing_loc': 'xyz',
'error': 'oopsie'
}
response = self.app.post(url,
data=json.dumps(data_dict),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch(
'api.providers.production.production_provider.ProductionProvider.set_product_unavailable',
production_provider.set_product_unavailable_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_post_production_api_set_product_unavailable(self):
url = "/production-api/v1/set_product_unavailable"
data_dict = {
'name': 't10000xyz401',
'orderid': '[email protected]',
'processing_loc': 'xyz',
'error': 'oopsie',
'note': 'them notes'
}
response = self.app.post(url,
data=json.dumps(data_dict),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch(
'api.providers.production.production_provider.ProductionProvider.mark_product_complete',
production_provider.set_mark_product_complete_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_post_production_api_mark_product_complete(self):
url = "/production-api/v1/mark_product_complete"
data_dict = {
'name': 't10000xyz401',
'orderid': '[email protected]',
'processing_loc': 'xyz',
'completed_file_location': '/tmp',
'cksum_file_location': '/tmp/txt.txt',
'log_file_contents': 'details'
}
response = self.app.post(url,
data=json.dumps(data_dict),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch(
'api.providers.production.production_provider.ProductionProvider.handle_orders',
production_provider.respond_true)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_post_production_api_handle_orders(self):
url = "/production-api/v1/handle-orders"
response = self.app.get(url,
data=json.dumps({}),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data is True
@patch(
'api.providers.production.production_provider.ProductionProvider.queue_products',
production_provider.queue_products_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_post_production_api_queue_products(self):
url = "/production-api/v1/queue-products"
data_dict = {
'order_name_tuple_list': 'order_name_tuple_list',
'processing_location': 'processing_location',
'job_name': 'job_name'
}
response = self.app.post(url,
data=json.dumps(data_dict),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.interfaces.production.version1.API.get_production_whitelist',
api.get_production_whitelist)
def test_get_production_api_configurations(self):
url = "/production-api/v1/configuration/system_message_title"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data.keys() == ['system_message_title']
@patch('api.interfaces.admin.version1.API.get_stat_whitelist',
api.get_stat_whitelist)
def test_get_production_api_stat_products_complete_24_hrs(self):
url = "/production-api/v1/statistics/stat_products_complete_24_hrs"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == 0
class TransportTestCase(unittest.TestCase):
def setUp(self):
os.environ['espa_api_testing'] = 'True'
# create a user
self.mock_user = MockUser()
self.mock_order = MockOrder()
self.user = User.find(self.mock_user.add_testing_user())
self.order_id = self.mock_order.generate_testing_order(self.user.id)
self.app = http.app.test_client()
self.app.testing = True
self.sceneids = self.mock_order.scene_names_list(self.order_id)[0:2]
token = ':'.join((self.user.username, 'foo'))
auth_string = "Basic {}".format(base64.b64encode(token))
self.headers = {"Authorization": auth_string}
with db_instance() as db:
uidsql = "select user_id, orderid from ordering_order limit 1;"
db.select(uidsql)
self.userid = db[0]['user_id']
self.orderid = db[0]['orderid']
itemsql = "select name, order_id from ordering_scene limit 1;"
db.select(itemsql)
self.itemid = db[0][0]
itemorderid = db[0][1]
ordersql = "select orderid from ordering_order where id = {};".format(
itemorderid)
db.select(ordersql)
self.itemorderid = db[0][0]
self.base_order = lowercase_all(testorders.build_base_order())
self.sensors = [
k for k in self.base_order.keys()
if isinstance(self.base_order[k], dict)
and 'inputs' in self.base_order[k]
]
self.inputs = {s: self.base_order[s]['inputs'] for s in self.sensors}
self.input_names_all = set([
i for sublist in [s for k, s in self.inputs.items()]
for i in sublist
])
def tearDown(self):
# clean up orders
self.mock_order.tear_down_testing_orders()
# clean up users
self.mock_user.cleanup()
os.environ['espa_api_testing'] = ''
def test_get_api_response_type(self):
response = self.app.get('/api',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
self.assertEqual(response.content_type, 'application/json')
@patch('api.domain.user.User.get', MockUser.get)
def test_get_api_response_content(self):
response = self.app.get('/api',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(set(['v1', 'v0']), set(resp_json.keys()))
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_api_info_response_content(self):
response = self.app.get('/api/v1',
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn("Version 1", resp_json['description'])
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
@patch(
'api.providers.ordering.ordering_provider.OrderingProvider.available_products',
mock_api.available_products)
def test_get_available_prods(self):
url = '/api/v1/available-products/' + ",".join(self.sceneids)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn("etm", resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
@patch(
'api.providers.ordering.ordering_provider.OrderingProvider.available_products',
mock_api.available_products)
def test_get_available_prods_json(self):
url = '/api/v1/available-products'
data_dict = {'inputs': self.sceneids}
response = self.app.get(url,
data=json.dumps(data_dict),
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('etm', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_available_orders_user(self):
url = "/api/v1/list-orders"
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIsInstance(resp_json, list)
self.assertListEqual(resp_json, [self.orderid])
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_available_orders_email(self):
# email param comes in as unicode
url = "/api/v1/list-orders/" + str(self.user.email)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIsInstance(resp_json, list)
self.assertListEqual(resp_json, [self.orderid])
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_by_ordernum(self):
url = "/api/v1/order/" + str(self.orderid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
items = {
'orderid', 'note', 'order_source', 'order_type', 'product_opts',
'priority', 'completion_date', 'status', 'order_date',
'product_options'
}
self.assertEqual(items, set(resp_json))
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_status_by_ordernum(self):
url = "/api/v1/order-status/" + str(self.orderid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual({'orderid', 'status'}, set(resp_json))
self.assertEqual(self.orderid, resp_json.get('orderid'))
self.assertEqual('ordered', resp_json.get('status'))
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum(self):
url = "/api/v1/item-status/%s" % self.itemorderid
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
all_names = set([s['name'].lower() for s in resp_json[self.orderid]])
all_names -= {'plot'}
self.assertEqual(self.input_names_all, all_names)
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum_itemnum(self):
url = "/api/v1/item-status/%s/%s" % (self.itemorderid, self.itemid)
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
all_names = set([s['name'].lower() for s in resp_json[self.orderid]])
self.assertEqual({self.itemid.lower()}, all_names)
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_current_user(self):
url = "/api/v1/user"
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('username', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_projections(self):
url = '/api/v1/projections'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('aea', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_formats(self):
url = '/api/v1/formats'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('formats', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_resampling(self):
url = '/api/v1/resampling-methods'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('resampling_methods', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_schema(self):
url = '/api/v1/order-schema'
response = self.app.get(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertIn('properties', resp_json.keys())
self.assertEqual(200, response.status_code)
@patch('api.domain.user.User.get', MockUser.get)
def test_bad_method(self):
url = '/api/v1/available-products/'
response = self.app.post(url,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(405, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
@patch('api.domain.user.User.get', MockUser.get)
def test_bad_data(self):
url = '/api/v1/order'
data = '{"inputs": [}'
response = self.app.post(url,
data=data,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(400, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
@patch('api.domain.user.User.get', MockUser.get)
def test_bad_validation_inputs(self):
url = '/api/v1/order'
data = '{"inputs": []}'
response = self.app.post(url,
data=data,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(400, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
self.assertIn('Schema errors', resp_json['messages']['errors'][0])
@patch('api.domain.user.User.get', MockUser.get)
def test_bad_validation_sensor_inputs(self):
url = '/api/v1/order'
data = '{"etm7_collection": {"inputs": ["LE07_L1TP_010028_20050420_20160925_01_T1"]}}'
response = self.app.post(url,
data=data,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(400, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
self.assertIn('2 validation errors',
resp_json['messages']['errors'][0])
@patch('api.domain.user.User.get', MockUser.get)
def test_bad_data_avail_inputs(self):
url = '/api/v1/available-products/'
data = '{"bad": []}'
response = self.app.get(url,
data=data,
headers=self.headers,
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(400, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
self.assertIn('No input products supplied',
resp_json['messages']['errors'][0])
@patch('api.external.ers.ERSApi._api_post',
lambda x, y, z: {'errors': True})
def test_messages_field_acc_denied(self):
url = '/api/v1/available-products/'
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(401, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn('errors', resp_json['messages'])
@patch('api.domain.user.User.get', MockUser.get)
def test_not_found(self):
url = '/api/v1/not-valid'
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(404, response.status_code)
self.assertIn('messages', resp_json)
self.assertIn("errors", resp_json['messages'])
@patch('api.domain.user.User.get', MockUser.get)
@patch('api.interfaces.ordering.version1.API.place_order',
MockOrder.place_order)
def test_post_order(self):
url = '/api/v1/order'
data = {'etm7_collection': {'inputs': [''], 'products': ['']}}
response = self.app.post(url,
headers=self.headers,
data=json.dumps(data),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(201, response.status_code)
self.assertEqual({'orderid', 'status'}, set(resp_json.keys()))
@patch('api.domain.user.User.get', MockUser.get)
@patch('api.interfaces.ordering.version1.API.cancel_order',
MockOrder.cancel_order)
def test_cancel_order(self):
url = '/api/v1/order'
data = {'orderid': self.orderid, 'status': 'cancelled'}
response = self.app.put(url,
headers=self.headers,
data=json.dumps(data),
environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(data, resp_json)
self.assertEqual(202, response.status_code)
class TransportTestCase(unittest.TestCase):
def setUp(self):
os.environ['espa_api_testing'] = 'True'
# create a user
self.mock_user = MockUser()
self.mock_order = MockOrder()
self.user = User.find(self.mock_user.add_testing_user())
self.order_id = self.mock_order.generate_testing_order(self.user.id)
self.app = http.app.test_client()
self.app.testing = True
self.sceneids = self.mock_order.scene_names_list(self.order_id)[0:2]
token = ''.format(self.user.username, 'foo')
auth_string = "Basic {}".format(base64.b64encode(token))
self.headers = {"Authorization": auth_string}
with db_instance() as db:
uidsql = "select user_id, orderid from ordering_order limit 1;"
db.select(uidsql)
self.userid = db[0]['user_id']
self.orderid = db[0]['orderid']
itemsql = "select name, order_id from ordering_scene limit 1;"
db.select(itemsql)
self.itemid = db[0][0]
itemorderid = db[0][1]
ordersql = "select orderid from ordering_order where id = {};".format(itemorderid)
db.select(ordersql)
self.itemorderid = db[0][0]
self.base_order = lowercase_all(testorders.build_base_order())
def tearDown(self):
# clean up orders
self.mock_order.tear_down_testing_orders()
# clean up users
self.mock_user.cleanup()
os.environ['espa_api_testing'] = ''
def test_get_api_response_type(self):
response = self.app.get('/api', headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
assert response.content_type == 'application/json'
def test_get_api_response_content(self):
response = self.app.get('/api', headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
self.assertEqual(set(['1', '0']), set(resp_json.keys()))
@patch('api.domain.user.User.get', MockUser.get)
def test_get_api_info_response_content(self):
response = self.app.get('/api/v1', headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "Version 1" in resp_json['description']
@patch('api.domain.user.User.get', MockUser.get)
@patch('api.providers.ordering.ordering_provider.OrderingProvider.available_products', mock_api.available_products)
def test_get_available_prods(self):
url = '/api/v1/available-products/' + ",".join(self.sceneids)
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "etm" in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
@patch('api.providers.ordering.ordering_provider.OrderingProvider.available_products', mock_api.available_products)
def test_post_available_prods(self):
url = '/api/v1/available-products'
data_dict = {'inputs': self.sceneids}
response = self.app.post(url, data=json.dumps(data_dict), headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert "etm" in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
@patch('api.providers.ordering.ordering_provider.OrderingProvider.fetch_user_orders', mock_ordering_provider.fetch_user_orders)
def test_get_available_orders_user(self):
url = "/api/v1/list-orders"
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert resp_json.keys() == ['orders']
@patch('api.domain.user.User.get', MockUser.get)
def test_get_available_orders_email(self):
# email param comes in as unicode
url = "/api/v1/list-orders/" + str(self.user.email)
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert resp_json.keys() == ['orders']
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_by_ordernum(self):
url = "/api/v1/order/" + str(self.orderid)
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_status_by_ordernum(self):
url = "/api/v1/order-status/" + str(self.orderid)
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum(self):
url = "/api/v1/item-status/%s" % self.itemorderid
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_item_status_by_ordernum_itemnum(self):
url = "/api/v1/item-status/%s/%s" % (self.itemorderid, self.itemid)
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'orderid' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_current_user(self):
url = "/api/v1/user"
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'username' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_projections(self):
url = '/api/v1/projections'
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'aea' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_formats(self):
url = '/api/v1/formats'
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'formats' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_resampling(self):
url = '/api/v1/resampling-methods'
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'resampling_methods' in resp_json.keys()
@patch('api.domain.user.User.get', MockUser.get)
def test_get_order_schema(self):
url = '/api/v1/order-schema'
response = self.app.get(url, headers=self.headers, environ_base={'REMOTE_ADDR': '127.0.0.1'})
resp_json = json.loads(response.get_data())
assert 'properties' in resp_json.keys()
# Waiting for DB mock-ups to be finished
def test_post_order(self):
pass
class ProductionTransportTestCase(unittest.TestCase):
def setUp(self):
os.environ['espa_api_testing'] = 'True'
# create a user
self.mock_user = MockUser()
self.mock_order = MockOrder()
self.user = User.find(self.mock_user.add_testing_user())
self.order_id = self.mock_order.generate_testing_order(self.user.id)
self.app = http.app.test_client()
self.app.testing = True
self.sceneids = self.mock_order.scene_names_list(self.order_id)[0:2]
with db_instance() as db:
uidsql = "select user_id, orderid from ordering_order limit 1;"
db.select(uidsql)
self.userid = db[0]['user_id']
self.orderid = db[0]['orderid']
itemsql = "select name, order_id from ordering_scene limit 1;"
db.select(itemsql)
self.itemid = db[0][0]
itemorderid = db[0][1]
ordersql = "select orderid from ordering_order where id = {};".format(itemorderid)
db.select(ordersql)
self.itemorderid = db[0][0]
self.base_order = lowercase_all(testorders.build_base_order())
def tearDown(self):
# clean up orders
self.mock_order.tear_down_testing_orders()
# clean up users
self.mock_user.cleanup()
os.environ['espa_api_testing'] = ''
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_get_production_api(self):
response = self.app.get('/production-api', environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response.content_type == 'application/json'
assert set(response_data.keys()) == set(['0', '1'])
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_get_production_api_v1(self):
response = self.app.get('/production-api/v1', environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert set(response_data.keys()) == set(["operations", "description"])
assert "ESPA Production" in response_data['description']
@patch('api.providers.production.production_provider.ProductionProvider.get_products_to_process',
production_provider.get_products_to_process_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_get_production_api_products_modis(self):
url = "/production-api/v1/products?for_user=bilbo&product_types=modis"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
correct_resp = {'encode_urls': False, 'for_user': '******',
'record_limit': 500, 'product_types': 'modis',
'priority': None}
assert response_data == correct_resp
@patch('api.providers.production.production_provider.ProductionProvider.get_products_to_process',
production_provider.get_products_to_process_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_get_production_api_products_landsat(self):
url = "/production-api/v1/products?for_user=bilbo&product_types=landsat"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
correct_resp = {'encode_urls': False, 'for_user': '******',
'record_limit': 500, 'product_types': 'landsat',
'priority': None}
assert response_data == correct_resp
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
@patch('api.providers.production.production_provider.ProductionProvider.update_status',
production_provider.update_status_inputs)
def test_post_production_api_update_status(self):
url = "/production-api/v1/update_status"
data_dict = {'name': 't10000xyz401', 'orderid': '[email protected]',
'processing_loc': 'update_status', 'status': 'updated'}
response = self.app.post(url, data=json.dumps(data_dict), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.providers.production.production_provider.ProductionProvider.set_product_error',
production_provider.set_product_error_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_post_production_api_set_product_error(self):
url = "/production-api/v1/set_product_error"
data_dict = {'name': 't10000xyz401', 'orderid': '[email protected]',
'processing_loc': 'xyz', 'error': 'oopsie'}
response = self.app.post(url, data=json.dumps(data_dict), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.providers.production.production_provider.ProductionProvider.set_product_unavailable',
production_provider.set_product_unavailable_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_post_production_api_set_product_unavailable(self):
url = "/production-api/v1/set_product_unavailable"
data_dict = {'name': 't10000xyz401', 'orderid': '[email protected]',
'processing_loc': 'xyz', 'error': 'oopsie', 'note': 'them notes'}
response = self.app.post(url, data=json.dumps(data_dict), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.providers.production.production_provider.ProductionProvider.mark_product_complete',
production_provider.set_mark_product_complete_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_post_production_api_mark_product_complete(self):
url = "/production-api/v1/mark_product_complete"
data_dict = {'name': 't10000xyz401', 'orderid': '[email protected]',
'processing_loc': 'xyz',
'completed_file_location': '/tmp',
'cksum_file_location': '/tmp/txt.txt',
'log_file_contents': 'details'}
response = self.app.post(url, data=json.dumps(data_dict), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.providers.production.production_provider.ProductionProvider.handle_orders',
production_provider.respond_true)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_post_production_api_handle_orders(self):
url = "/production-api/v1/handle-orders"
response = self.app.get(url, data=json.dumps({}), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data is True
@patch('api.providers.production.production_provider.ProductionProvider.queue_products',
production_provider.queue_products_inputs)
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_post_production_api_queue_products(self):
url = "/production-api/v1/queue-products"
data_dict = {'order_name_tuple_list': 'order_name_tuple_list',
'processing_location': 'processing_location',
'job_name': 'job_name'}
response = self.app.post(url, data=json.dumps(data_dict), environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data == data_dict
@patch('api.interfaces.production.version1.API.get_production_whitelist', api.get_production_whitelist)
def test_get_production_api_configurations(self):
url = "/production-api/v1/configuration/system_message_title"
response = self.app.get(url, environ_base={'REMOTE_ADDR': '127.0.0.1'})
response_data = json.loads(response.get_data())
assert response_data.keys() == ['system_message_title']